KaneAI - World’s First E2E Software Testing Agent.Book a Demo Join TestMu Conference

How to use ConstructorInvokingMethodShouldNotRaiseExceptionTest class of org.mockitousage.bugs.creation package

Best Mockito code snippet using org.mockitousage.bugs.creation.ConstructorInvokingMethodShouldNotRaiseExceptionTest

Source: ConstructorInvokingMethodShouldNotRaiseExceptionTest.java

...5import org.mockito.MockitoAnnotations;6import org.mockito.Spy;7import java.util.Random;8@RunWith(Enclosed.class)9public class ConstructorInvokingMethodShouldNotRaiseExceptionTest {10    public static class WithDumbMethod {11        @Spy12        HasConstructorInvokingMethod hasConstructorInvokingMethod;13        @Test14        public void should_be_able_to_create_spy() throws Exception {15            MockitoAnnotations.initMocks(this);16        }17        private static class HasConstructorInvokingMethod {18            public HasConstructorInvokingMethod() { someMethod(); }19            void someMethod() { }20        }21    }22    public static class UsingMethodObjectReferenceResult {23        @Spy...

ConstructorInvokingMethodShouldNotRaiseExceptionTest

Using AI Code Generation

1[org.mockitousage.bugs.creation.ConstructorInvokingMethodShouldNotRaiseExceptionTest]: # (start)2[org.mockitousage.bugs.creation.ConstructorInvokingMethodShouldNotRaiseExceptionTest]: # (end)3[org.mockitousage.bugs.creation.ConstructorInvokingMethodShouldNotRaiseExceptionTest]: # (start)4[org.mockitousage.bugs.creation.ConstructorInvokingMethodShouldNotRaiseExceptionTest]: # (end)5[org.mockitousage.bugs.creation.ConstructorInvokingMethodShouldNotRaiseExceptionTest]: # (start)6[org.mockitousage.bugs.creation.ConstructorInvokingMethodShouldNotRaiseExceptionTest]: # (end)7[org.mockitousage.bugs.creation.ConstructorInvokingMethodShouldNotRaiseExceptionTest]: # (start)8[org.mockitousage.bugs.creation.ConstructorInvokingMethodShouldNotRaiseExceptionTest]: # (end)9[org.mockitousage.bugs.creation.ConstructorInvokingMethodShouldNotRaiseExceptionTest]: # (start)10[org.mockitousage.bugs.creation.ConstructorInvokingMethodShouldNotRaiseExceptionTest]: # (end)11[org.mockitousage.bugs.creation.ConstructorInvokingMethodShouldNotRaiseExceptionTest]: # (start)12[org.mockitousage.bugs.creation.ConstructorInvokingMethodShouldNotRaiseExceptionTest]: # (end)13[org.mockitousage.bugs.creation.ConstructorInvokingMethodShouldNotRaiseExceptionTest]: # (start)14[org.mockitousage.bugs.creation.ConstructorInvokingMethodShouldNotRaiseExceptionTest]: # (end)15[org.mockitousage.bugs.creation.ConstructorInvokingMethodShouldNotRaiseExceptionTest]: # (start)16[org.mockitousage.bugs.creation.ConstructorInvokingMethodShouldNotRaiseExceptionTest]: # (end)17[org.mockitousage.bugs.creation.ConstructorInvokingMethodShouldNotRaiseExceptionTest]: # (start)18[org.mockitousage.bugs.creation.ConstructorInvokingMethodShouldNotRaiseExceptionTest]: # (end)19[org.mockitousage.bugs.creation.ConstructorInvokingMethodShouldNotRaiseExceptionTest]: # (start)20[org.mockitousage.bugs.creation.ConstructorInvokingMethodShouldNotRaiseExceptionTest]: # (end)21[org.mockitousage.bugs.creation.ConstructorInvokingMethodShouldNotRaiseExceptionTest]: # (start)

StackOverFlow community discussions

Questions

Discussion

Mockito Spy - stub before calling the constructor

Maven: compiling and testing on different source levels

Verify Static Method Call using PowerMockito 1.6

How do I use Powermockito to mock the construction of new objects when testing a method in an anonymous class?

Mockito Exception - when() requires an argument which has to be a method call on a mock

Unit Tests How to Mock Repository Using Mockito

How can I tell if an object is a Mockito mock?

Checking consistency of multiple arguments using Mockito

Mocking Logger and LoggerFactory with PowerMock and Mockito

Jar/Class problems with Jetty WebSockets

To answer your question directly, you cannot use Mockito to stub a method called from the constructor. Mockito needs an instance of the class before you can begin mocking, and you haven't given yourself a way to create an instance for testing.

More generally, as mentioned in Effective Java item 17, you should not call overridable methods from constructors. If you do so, for instance, you could provide an override in a subclass that refers to a final field but that runs before the final field is set. It probably won't get you in trouble here, but it's a bad habit in Java.

Luckily, you can restructure your code to do this very easily:

public class MyClass {
  public MyClass() {
    this(true);
  }

  /** For testing. */
  MyClass(boolean runSetup) {
    if (runSetup) {
      setup();
    }
  }

  /* ... */
}

To make it even more obvious, you can make the one-parameter MyClass constructor private, and provide a public static factory method:

/* ... */
  public static MyClass createForTesting() {
    return new MyClass(false);
  }

  private MyClass(boolean runSetup) {
/* ... */

Though some developers think it is a bad practice to write any code in methods that is used mostly for tests, remember that you are in charge of the design of your code, and tests are one of few consumers you absolutely know you will need to accommodate. Though it's still a good idea to avoid explicit test setup in "production" code, creating extra methods or overloads for the sake of testing will usually make your code cleaner overall and can drastically improve your test coverage and readability.

https://stackoverflow.com/questions/23598147/mockito-spy-stub-before-calling-the-constructor

The source and target versions can be set separately for the compile and testCompile goals of the maven compiler plugin. You can change the settings either by defining properties in your pom:

<properties>
    <maven.compiler.source>1.4</maven.compiler.source>
    <maven.compiler.target>1.4</maven.compiler.target>
    <maven.compiler.testSource>1.5</maven.compiler.testSource>
    <maven.compiler.testTarget>1.5</maven.compiler.testTarget>
</properties>

Or by explicit configuration of the compiler plugin:

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-compiler-plugin</artifactId>
    <version>2.4</version>
    <configuration>
        <source>1.4</source>
        <target>1.4</target>
        <testSource>1.5</testSource>
        <testTarget>1.5</testTarget>
    </configuration>
</plugin>

https://stackoverflow.com/questions/10604007/maven-compiling-and-testing-on-different-source-levels

Personally, I have to say that PowerMock, etc. is the solution to a problem that you shouldn't have if your code wasn't bad. In some cases, it is required because frameworks, etc. use static methods that lead to code that simply cannot be tested otherwise, but if it's about YOUR code, you should always prefer refactoring instead of static mocking.

Anyway, verifing that in PowerMockito shouldn't be that hard...

PowerMockito.verifyStatic( Mockito.times(1)); // Verify that the following mock method was called exactly 1 time
SampleB.methodC();

(Of course, for this to work you must add SampleB to the @PrepareForTest annotation and call mockStatic for it.)

https://stackoverflow.com/questions/34323909/verify-static-method-call-using-powermockito-1-6

The message is pretty obvious: You can't mock non-visible and final classes. Short answer : Create a named class of your anonymous one, and test this class instead!

Long answer, let's dig why !

An anonymous class is final

You instantiate an anonymous class of FilterFactory, when the compiler sees an anonymous class, it creates a final and package visible class. So the anonymous class is not mockable through standard mean i.e. through Mockito.

Mocking anonymous class : possible but BRITTLE if not HACKY

OK, now suppose you want to be able to mock this anonymous class through Powermock. Current compilers compile anonymous class with following scheme :

Declaring class + $ + <order of declaration starting with 1>

Mocking anonymous class possible but brittle (And I mean it) So supposing the anonymous class is the eleventh to be declared, it will appear as

InputHelper$11.class

So you could potentially prepare for test the anonymous class:

@RunWith(PowerMockRunner.class)
@PrepareForTest({InputHelper$11.class})
public class InputHelperTest {
    @Test
    public void anonymous_class_mocking works() throws Throwable {
        PowerMockito.spy(InputHelper.BZIP2_FACTORY);  // This line fails
    }
}

This code will compile, BUT will eventually be reported as an error with your IDE. The IDE probably doesn't know about InputHelper$11.class. IntelliJ who doesn't use compiled class to check the code report so.

Also the fact that the anonymous class naming actually depends on the order of the declaration is a problem, when someone adds another anonymous class before, the numbering could change. Anonymous classes are made to stay anonymous, what if the compiler guys decide one day to use letters or even random identifiers!

So mocking anonymous classes through Powermock is possible but brittle, don't ever do that in a real project!

EDITED NOTE : The Eclipse compiler has a different numbering scheme, it always uses a 3 digit number :

Declaring class + $ + <pad with 0> + <order of declaration starting with 1>

Also I don't think the JLS clearly specify how the compilers should name anonymous classes.

You don't reassign the spy to the static field

PowerMockito.spy(InputHelper.BZIP2_FACTORY);  // This line fails
whenNew(BufferedInputStream.class).withArguments(in).thenReturn(buffer);
whenNew(CBZip2InputStream.class).withArguments(buffer).thenReturn(expected);
InputStream observed = InputHelper.BZIP2_FACTORY.makeFilter(in);

PowerMockito.spy returns the spy, it doesn't change the value of InputHelper.BZIP2_FACTORY. So you would need to actually set via reflection this field. You can use the Whiteboxutility that Powermock provide.

Conclusion

Too much trouble to just test with mocks that the anonymous filter uses a BufferedInputStream.

Alternative

I would rather write the following code:

An input helper that will use the named class, I don't use the interface name to make clear to the user what is the intent of this filter!

public class InputHelper {
    public static final BufferedBZIP2FilterFactory BZIP2_FACTORY = new BufferedBZIP2FilterFactory();
}

And now the filter itself :

public class BufferedBZIP2FilterFactory {
    public InputStream makeFilter(InputStream in) {
        BufferedInputStream buffer = new BufferedInputStream(in);
        return new CBZip2InputStream(buffer);
    }
}

Now you can write a test like this :

@RunWith(PowerMockRunner.class)
public class BufferedBZIP2FilterFactoryTest {

    @Test
    @PrepareForTest({BufferedBZIP2FilterFactory.class})
    public void wraps_InputStream_in_BufferedInputStream() throws Exception {
        whenNew(CBZip2InputStream.class).withArguments(isA(BufferedInputStream.class))
                .thenReturn(Mockito.mock(CBZip2InputStream.class));

        new BufferedBZIP2FilterFactory().makeFilter(anInputStream());

        verifyNew(CBZip2InputStream.class).withArguments(isA(BufferedInputStream.class));
    }

    private ByteArrayInputStream anInputStream() {
        return new ByteArrayInputStream(new byte[10]);
    }
}

But could eventually avoid powermock stuff for this test scenario if you force the CBZip2InputStream to only accept BufferedInputStream. Usually using Powermock means something is wrong with the design. In my opinion Powermock is great for legacy softwares, but can blind developers when designing new code; as they are missing the point of OOP's good part, I would even say they are designing legacy code.

Hope that helps !

https://stackoverflow.com/questions/7523389/how-do-i-use-powermockito-to-mock-the-construction-of-new-objects-when-testing-a

You need to create a MOCK of pcUserService first, and then use that mock.

PcUserService mock = org.mockito.Mockito.mock(PcUserService.class);
when(mock.read("1")).thenReturn(pcUser);

https://stackoverflow.com/questions/9186604/mockito-exception-when-requires-an-argument-which-has-to-be-a-method-call-on

Let me begin by saying you are on the right track by using Constructor Injection and not Field Injection(which makes writing tests with mocks much simpler).

public class MyServiceImplTest 
{
    private MyDataService myDataService;
    private NyService myService;

    @Mock
    private MyRepository myRepository;

    @Before
    public void setUp() {
        MockitoAnnotations.initMocks(this); // this is needed for inititalizytion of mocks, if you use @Mock 
        myDataService = new MyDataServiceImpl(myRepository);
        myService = new MyServiceImpl(myDataService);
    }

    @Test
    public void getById_ValidId() {

        doReturn(someMockData).when(myRepository).findOne("1");
        MyObject myObject = myService.getById("1");

        //Whatever asserts need to be done on the object myObject 
    }
}

The call goes all the way from your service --> dataService. But only your repository calls are mocked.
This way you can control and test all the other parts of your classes(both service and dataService) and mock only repository calls.

https://stackoverflow.com/questions/51053469/unit-tests-how-to-mock-repository-using-mockito

As a follow up, the Mockito public API now has this method:

MockingDetails org.mockito.Mockito.mockingDetails(Object toInspect)

Which is the result of the issue that @David Wallace raised. The returned object supports the methods isMock() as well as isSpy() along with a few other methods that provide additional mocking information.

https://stackoverflow.com/questions/9035843/how-can-i-tell-if-an-object-is-a-mockito-mock

While a partial mock isn't a bad idea, you might find your code easier to follow if you use an ArgumentCaptor instead to get the values after the fact. It's a special argument matcher that keeps track of the value it matches.

// initialized with MockitoAnnotations.initMocks();
@Captor ArgumentCaptor<Integer> offsetCaptor;
@Captor ArgumentCaptor<float[]> floatsCaptor;
@Mock Bar bar;

@Test
public void valuesShouldBeCloseEnough() {
  Sut sut = new Sut(bar);
  sut.doSomething();
  verify(bar).setFoo(offsetCaptor.capture(), floatsCaptor.capture());

  // check values with assertValuesAreCloseEnough, declared elsewhere
  assertValuesAreCloseEnough(offsetCaptor.getValue(), floatsCaptor.getValue());
}

https://stackoverflow.com/questions/14694806/checking-consistency-of-multiple-arguments-using-mockito

EDIT 2020-09-21: Since 3.4.0, Mockito supports mocking static methods, API is still incubating and is likely to change, in particular around stubbing and verification. It requires the mockito-inline artifact. And you don't need to prepare the test or use any specific runner. All you need to do is :

@Test
public void name() {
    try (MockedStatic<LoggerFactory> integerMock = mockStatic(LoggerFactory.class)) {
        final Logger logger = mock(Logger.class);
        integerMock.when(() -> LoggerFactory.getLogger(any(Class.class))).thenReturn(logger);
        new Controller().log();
        verify(logger).warn(any());
    }
}

The two inportant aspect in this code, is that you need to scope when the static mock applies, i.e. within this try block. And you need to call the stubbing and verification api from the MockedStatic object.

@Mick, try to prepare the owner of the static field too, eg :

@PrepareForTest({GoodbyeController.class, LoggerFactory.class})

EDIT1 : I just crafted a small example. First the controller :

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class Controller {
    Logger logger = LoggerFactory.getLogger(Controller.class);

    public void log() { logger.warn("yup"); }
}

Then the test :

import org.junit.Test;
import org.junit.runner.RunWith;
import org.powermock.core.classloader.annotations.PrepareForTest;
import org.powermock.modules.junit4.PowerMockRunner;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import static org.mockito.Matchers.any;
import static org.mockito.Matchers.anyString;
import static org.mockito.Mockito.verify;
import static org.powermock.api.mockito.PowerMockito.mock;
import static org.powermock.api.mockito.PowerMockito.mockStatic;
import static org.powermock.api.mockito.PowerMockito.when;

@RunWith(PowerMockRunner.class)
@PrepareForTest({Controller.class, LoggerFactory.class})
public class ControllerTest {

    @Test
    public void name() throws Exception {
        mockStatic(LoggerFactory.class);
        Logger logger = mock(Logger.class);
        when(LoggerFactory.getLogger(any(Class.class))).thenReturn(logger);
        
        new Controller().log();
        
        verify(logger).warn(anyString());
    }
}

Note the imports ! Noteworthy libs in the classpath : Mockito, PowerMock, JUnit, logback-core, logback-clasic, slf4j

EDIT2 : As it seems to be a popular question, I'd like to point out that if these log messages are that important and require to be tested, i.e. they are feature / business part of the system then introducing a real dependency that make clear theses logs are features would be a so much better in the whole system design, instead of relying on static code of a standard and technical classes of a logger.

For this matter I would recommend to craft something like= a Reporter class with methods such as reportIncorrectUseOfYAndZForActionX or reportProgressStartedForActionX. This would have the benefit of making the feature visible for anyone reading the code. But it will also help to achieve tests, change the implementations details of this particular feature.

Hence you wouldn't need static mocking tools like PowerMock. In my opinion static code can be fine, but as soon as the test demands to verify or to mock static behavior it is necessary to refactor and introduce clear dependencies.

https://stackoverflow.com/questions/8948916/mocking-logger-and-loggerfactory-with-powermock-and-mockito

First, your command line, decomposed to make it readable:

"C:\Program Files\Java\jdk1.7.0_17\bin\java" 
  -Didea.launcher.port=7532 
  "-Didea.launcher.bin.path=C:\Program Files (x86)\JetBrains\IntelliJ IDEA Community Edition 12.1.6\bin" 
  -Dfile.encoding=UTF-8 
  -classpath "C:\Program Files\Java\jdk1.7.0_17\jre\lib\charsets.jar
    C:\Program Files\Java\jdk1.7.0_17\jre\lib\deploy.jar
    C:\Program Files\Java\jdk1.7.0_17\jre\lib\javaws.jar
    C:\Program Files\Java\jdk1.7.0_17\jre\lib\jce.jar
    C:\Program Files\Java\jdk1.7.0_17\jre\lib\jfr.jar
    C:\Program Files\Java\jdk1.7.0_17\jre\lib\jfxrt.jar
    C:\Program Files\Java\jdk1.7.0_17\jre\lib\jsse.jar
    C:\Program Files\Java\jdk1.7.0_17\jre\lib\management-agent.jar
    C:\Program Files\Java\jdk1.7.0_17\jre\lib\plugin.jar
    C:\Program Files\Java\jdk1.7.0_17\jre\lib\resources.jar
    C:\Program Files\Java\jdk1.7.0_17\jre\lib\rt.jar
    C:\Program Files\Java\jdk1.7.0_17\jre\lib\ext\access-bridge-64.jar
    C:\Program Files\Java\jdk1.7.0_17\jre\lib\ext\dnsns.jar
    C:\Program Files\Java\jdk1.7.0_17\jre\lib\ext\jaccess.jar
    C:\Program Files\Java\jdk1.7.0_17\jre\lib\ext\localedata.jar
    C:\Program Files\Java\jdk1.7.0_17\jre\lib\ext\sunec.jar
    C:\Program Files\Java\jdk1.7.0_17\jre\lib\ext\sunjce_provider.jar
    C:\Program Files\Java\jdk1.7.0_17\jre\lib\ext\sunmscapi.jar
    C:\Program Files\Java\jdk1.7.0_17\jre\lib\ext\zipfs.jar
    C:\Users\Alexandr.Alexandr-PC\Documents\java\Shooter\target\classes
    C:\Program Files (x86)\JetBrains\IntelliJ IDEA Community Edition 12.1.6\lib\junit-4.10.jar
    C:\Users\Alexandr.Alexandr-PC\.m2\repository\org\freemarker\freemarker\2.3.19\freemarker-2.3.19.jar
    C:\Users\Alexandr.Alexandr-PC\.m2\repository\org\eclipse\jetty\jetty-server\9.1.0.M0\jetty-server-9.1.0.M0.jar
    C:\Users\Alexandr.Alexandr-PC\.m2\repository\javax\servlet\javax.servlet-api\3.1.0\javax.servlet-api-3.1.0.jar
    C:\Users\Alexandr.Alexandr-PC\.m2\repository\org\eclipse\jetty\jetty-http\9.1.0.M0\jetty-http-9.1.0.M0.jar
    C:\Users\Alexandr.Alexandr-PC\.m2\repository\org\eclipse\jetty\jetty-util\9.1.0.M0\jetty-util-9.1.0.M0.jar
    C:\Users\Alexandr.Alexandr-PC\.m2\repository\org\eclipse\jetty\jetty-io\9.1.0.M0\jetty-io-9.1.0.M0.jar
    C:\Users\Alexandr.Alexandr-PC\.m2\repository\org\eclipse\jetty\jetty-webapp\9.1.0.M0\jetty-webapp-9.1.0.M0.jar
    C:\Users\Alexandr.Alexandr-PC\.m2\repository\org\eclipse\jetty\jetty-xml\9.1.0.M0\jetty-xml-9.1.0.M0.jar
    C:\Users\Alexandr.Alexandr-PC\.m2\repository\org\eclipse\jetty\jetty-servlet\9.1.0.M0\jetty-servlet-9.1.0.M0.jar
    C:\Users\Alexandr.Alexandr-PC\.m2\repository\org\eclipse\jetty\jetty-security\9.1.0.M0\jetty-security-9.1.0.M0.jar
    C:\Users\Alexandr.Alexandr-PC\.m2\repository\org\eclipse\jetty\jetty-rewrite\9.1.0.M0\jetty-rewrite-9.1.0.M0.jar
    C:\Users\Alexandr.Alexandr-PC\.m2\repository\org\eclipse\jetty\jetty-client\9.1.0.M0\jetty-client-9.1.0.M0.jar
    C:\Users\Alexandr.Alexandr-PC\.m2\repository\org\mockito\mockito-all\1.8.4\mockito-all-1.8.4.jar
    C:\Users\Alexandr.Alexandr-PC\.m2\repository\org\seleniumhq\selenium\selenium-java\2.4.0\selenium-java-2.4.0.jar
    C:\Users\Alexandr.Alexandr-PC\.m2\repository\org\seleniumhq\selenium\selenium-android-driver\2.4.0\selenium-android-driver-2.4.0.jar
    C:\Users\Alexandr.Alexandr-PC\.m2\repository\org\seleniumhq\selenium\selenium-remote-driver\2.4.0\selenium-remote-driver-2.4.0.jar
    C:\Users\Alexandr.Alexandr-PC\.m2\repository\cglib\cglib-nodep\2.1_3\cglib-nodep-2.1_3.jar
    C:\Users\Alexandr.Alexandr-PC\.m2\repository\org\json\json\20080701\json-20080701.jar
    C:\Users\Alexandr.Alexandr-PC\.m2\repository\org\seleniumhq\selenium\selenium-api\2.4.0\selenium-api-2.4.0.jar
    C:\Users\Alexandr.Alexandr-PC\.m2\repository\com\google\guava\guava\r09\guava-r09.jar
    C:\Users\Alexandr.Alexandr-PC\.m2\repository\org\apache\httpcomponents\httpclient\4.0.2\httpclient-4.0.2.jar
    C:\Users\Alexandr.Alexandr-PC\.m2\repository\org\apache\httpcomponents\httpcore\4.0.1\httpcore-4.0.1.jar
    C:\Users\Alexandr.Alexandr-PC\.m2\repository\commons-logging\commons-logging\1.1.1\commons-logging-1.1.1.jar
    C:\Users\Alexandr.Alexandr-PC\.m2\repository\commons-codec\commons-codec\1.4\commons-codec-1.4.jar
    C:\Users\Alexandr.Alexandr-PC\.m2\repository\org\seleniumhq\selenium\selenium-chrome-driver\2.4.0\selenium-chrome-driver-2.4.0.jar
    C:\Users\Alexandr.Alexandr-PC\.m2\repository\org\seleniumhq\selenium\selenium-htmlunit-driver\2.4.0\selenium-htmlunit-driver-2.4.0.jar
    C:\Users\Alexandr.Alexandr-PC\.m2\repository\net\sourceforge\htmlunit\htmlunit\2.8\htmlunit-2.8.jar
    C:\Users\Alexandr.Alexandr-PC\.m2\repository\xalan\xalan\2.7.1\xalan-2.7.1.jar
    C:\Users\Alexandr.Alexandr-PC\.m2\repository\xalan\serializer\2.7.1\serializer-2.7.1.jar
    C:\Users\Alexandr.Alexandr-PC\.m2\repository\xml-apis\xml-apis\1.3.04\xml-apis-1.3.04.jar
    C:\Users\Alexandr.Alexandr-PC\.m2\repository\commons-collections\commons-collections\3.2.1\commons-collections-3.2.1.jar
    C:\Users\Alexandr.Alexandr-PC\.m2\repository\commons-lang\commons-lang\2.4\commons-lang-2.4.jar
    C:\Users\Alexandr.Alexandr-PC\.m2\repository\org\apache\httpcomponents\httpmime\4.0.1\httpmime-4.0.1.jar
    C:\Users\Alexandr.Alexandr-PC\.m2\repository\org\apache\james\apache-mime4j\0.6\apache-mime4j-0.6.jar
    C:\Users\Alexandr.Alexandr-PC\.m2\repository\net\sourceforge\htmlunit\htmlunit-core-js\2.8\htmlunit-core-js-2.8.jar
    C:\Users\Alexandr.Alexandr-PC\.m2\repository\xerces\xercesImpl\2.9.1\xercesImpl-2.9.1.jar
    C:\Users\Alexandr.Alexandr-PC\.m2\repository\net\sourceforge\nekohtml\nekohtml\1.9.14\nekohtml-1.9.14.jar
    C:\Users\Alexandr.Alexandr-PC\.m2\repository\net\sourceforge\cssparser\cssparser\0.9.5\cssparser-0.9.5.jar
    C:\Users\Alexandr.Alexandr-PC\.m2\repository\org\w3c\css\sac\1.3\sac-1.3.jar
    C:\Users\Alexandr.Alexandr-PC\.m2\repository\commons-io\commons-io\2.0.1\commons-io-2.0.1.jar
    C:\Users\Alexandr.Alexandr-PC\.m2\repository\org\seleniumhq\selenium\selenium-firefox-driver\2.4.0\selenium-firefox-driver-2.4.0.jar
    C:\Users\Alexandr.Alexandr-PC\.m2\repository\org\seleniumhq\selenium\selenium-ie-driver\2.4.0\selenium-ie-driver-2.4.0.jar
    C:\Users\Alexandr.Alexandr-PC\.m2\repository\net\java\dev\jna\jna\3.2.3\jna-3.2.3.jar
    C:\Users\Alexandr.Alexandr-PC\.m2\repository\org\seleniumhq\selenium\selenium-iphone-driver\2.4.0\selenium-iphone-driver-2.4.0.jar
    C:\Users\Alexandr.Alexandr-PC\.m2\repository\org\seleniumhq\selenium\selenium-support\2.4.0\selenium-support-2.4.0.jar
    C:\Users\Alexandr.Alexandr-PC\.m2\repository\junit\junit\4.11\junit-4.11.jar
    C:\Users\Alexandr.Alexandr-PC\.m2\repository\org\hamcrest\hamcrest-core\1.3\hamcrest-core-1.3.jar
    C:\Users\Alexandr.Alexandr-PC\.m2\repository\org\eclipse\jetty\jetty-websocket\7.4.4.v20110707\jetty-websocket-7.4.4.v20110707.jar
    C:\Users\Alexandr.Alexandr-PC\.m2\repository\javax\servlet\servlet-api\2.5\servlet-api-2.5.jar
    C:\Program Files (x86)\JetBrains\IntelliJ IDEA Community Edition 12.1.6\lib\idea_rt.jar" 
  com.intellij.rt.execution.application.AppMain servlets.SimpleEchoClient

And your first line of output from your program

2013-12-01 00:52:53.727:INFO:oejs.Server:main: jetty-9.1.0.M0

You have multiple things to take care of.

You are running mixed versions of Jetty. Your jetty websockets is at 7.4.4.v20110707 while the rest of Jetty is at 9.1.0.M0.
You should upgrade to the final (non-milestone, non-release candidate) version of Jetty 9.1 for the most mature websocket implementation. That would be jetty 9.1.0.v20131115
Your code example is for the early draft implementations of websocket, and shows you are looking at some extremely old code examples. Would discourage you from using that long since deprecated API.
Your version of Java is old. 1.7 update 17 expired back in June (yes, Java versions expire. Read the release notes. eg: u40 expires on 12/10/2013, and u45 expires on 1/14/2014)
Use either the Modern Jetty WebSocket API, or the javax.websocket standard API.

Modern Jetty WebSocket API

An example project has been setup at:

https://github.com/jetty-project/embedded-jetty-websocket-examples/tree/master/native-jetty-websocket-example

The maven dependencies you'll need:

<!-- To write basic websockets against -->
<dependency>
  <groupId>org.eclipse.jetty.websocket</groupId>
  <artifactId>websocket-api</artifactId>
  <version>9.1.0.v20131115</version>
</dependency>
<!-- To run websockets in embedded server -->
<dependency>
  <groupId>org.eclipse.jetty.websocket</groupId>
  <artifactId>websocket-server</artifactId>
  <version>9.1.0.v20131115</version>
</dependency>
<!-- To run websockets client -->
<dependency>
  <groupId>org.eclipse.jetty.websocket</groupId>
  <artifactId>websocket-client</artifactId>
  <version>9.1.0.v20131115</version>
</dependency>

Look at the example code.

EventServer.java - this the jetty embedded server code, to initialize the handler tree + ServletContext. It maps the EventServlet to the path spec of "/events/*"
EventServlet.java - this simply registers the EventSocket with the Servlet (For background, the WebSocketServletFactory has a simple default implementation of WebSocketCreator that only supports 1 websocket. The .register(Class<?>) call simply tells this default WebSocketCreator what WebSocket to create. If you want a more complex WebSocketCreator, then you would call WebSocketServletFactory.setCreator(WebSocketCreator) with your own implementation)
EventSocket.java - the actual websocket that receives the incoming events
EventClient.java - since your demo code was called client, but had server code in it, I didn't really know what you were planning, so i tossed in a Native Jetty WebSocket Client example as well.

javax.websocket standard API on Jetty

An example project has been setup at:

https://github.com/jetty-project/embedded-jetty-websocket-examples/tree/master/javax.websocket-example

The maven dependencies you'll need:

<!-- To write basic javax.websocket against -->
<dependency>
  <groupId>javax.websocket</groupId>
  <artifactId>javax.websocket-api</artifactId>
  <version>1.0</version>
</dependency>
<!-- To run javax.websocket in embedded server -->
<dependency>
  <groupId>org.eclipse.jetty.websocket</groupId>
  <artifactId>javax-websocket-server-impl</artifactId>
  <version>9.1.0.v20131115</version>
</dependency>
<!-- To run javax.websocket client -->
<dependency>
  <groupId>org.eclipse.jetty.websocket</groupId>
  <artifactId>javax-websocket-client-impl</artifactId>
  <version>9.1.0.v20131115</version>
</dependency>

Look at the example code.

EventServer.java - this is slightly different than the Native API, as everything in the javax.websocket world is based on Annotations with discovery. So this embedded server establishes a ServletContextHandler, then initializes the javax.websocket layer with a call to WebSocketServerContainerInitializer.configureContext(context), finally with a manual addEndpoint(Class) against the ServerContainer.
EventSocket.java - using the annotations for javax.websocket, this class is both annotated to be a Server endpoint and a Client endpoint, with the methods that should receive the various events also annotated to indicate their desired purpose.
EventClient.java - this uses the javax.websocket WebSocketContainer (client container) to connect to the server and send a message. (of particular note, is the extra work to cleanup the lifecycle of the WebSocketContainer. a missing feature from the JSR-356 spec)

Good luck

https://stackoverflow.com/questions/20304993/jar-class-problems-with-jetty-websockets

Blogs

Check out the latest blogs from LambdaTest on this topic:

Putting Together a Testing Team

As part of one of my consulting efforts, I worked with a mid-sized company that was looking to move toward a more agile manner of developing software. As with any shift in work style, there is some bewilderment and, for some, considerable anxiety. People are being challenged to leave their comfort zones and embrace a continuously changing, dynamic working environment. And, dare I say it, testing may be the most ‘disturbed’ of the software roles in agile development.

Top 7 Programming Languages For Test Automation In 2020

So you are at the beginning of 2020 and probably have committed a new year resolution as a tester to take a leap from Manual Testing To Automation . However, to automate your test scripts you need to get your hands dirty on a programming language and that is where you are stuck! Or you are already proficient in automation testing through a single programming language and are thinking about venturing into new programming languages for automation testing, along with their respective frameworks. You are bound to be confused about picking your next milestone. After all, there are numerous programming languages to choose from.

Dec’22 Updates: The All-New LT Browser 2.0, XCUI App Automation with HyperExecute, And More!

Greetings folks! With the new year finally upon us, we’re excited to announce a collection of brand-new product updates. At LambdaTest, we strive to provide you with a comprehensive test orchestration and execution platform to ensure the ultimate web and mobile experience.

LIVE With Automation Testing For OTT Streaming Devices ????

People love to watch, read and interact with quality content — especially video content. Whether it is sports, news, TV shows, or videos captured on smartphones, people crave digital content. The emergence of OTT platforms has already shaped the way people consume content. Viewers can now enjoy their favorite shows whenever they want rather than at pre-set times. Thus, the OTT platform’s concept of viewing anything, anytime, anywhere has hit the right chord.

QA’s and Unit Testing – Can QA Create Effective Unit Tests

Unit testing is typically software testing within the developer domain. As the QA role expands in DevOps, QAOps, DesignOps, or within an Agile team, QA testers often find themselves creating unit tests. QA testers may create unit tests within the code using a specified unit testing tool, or independently using a variety of methods.

Automation Testing Tutorials

Learn to execute automation testing from scratch with LambdaTest Learning Hub. Right from setting up the prerequisites to run your first automation test, to following best practices and diving deeper into advanced test scenarios. LambdaTest Learning Hubs compile a list of step-by-step guides to help you be proficient with different test automation frameworks i.e. Selenium, Cypress, TestNG etc.