org.junit.Ignore Java Examples

@Ignore
   @Test
   @SuppressWarnings({ "rawtypes", "unchecked" })
   public void testBuilder_MyList() throws Exception
{
       Builder<MyList> b1 = Builder.register(MyList.class);
	MyList list = new MyList();
	list.add(new boolean[]{ true,false });
	list.add(new int[]{ 1,2,3,4,5 });
	list.add("String");
	list.add(4);
	list.code = 4321;
	
	UnsafeByteArrayOutputStream os = new UnsafeByteArrayOutputStream();
	b1.writeTo(list, os);
	byte[] b = os.toByteArray();
	System.out.println(b.length+":"+Bytes.bytes2hex(b));
	MyList result = b1.parseFrom(b);

	assertEquals(4, result.size());
	assertEquals(result.code, 4321);
	assertEquals(result.id, "feedback");
}
 

@Ignore
@Test
public void testAsFromTupleToPojo() throws Exception {
	ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment();
	BatchTableEnvironment tableEnv = BatchTableEnvironment.create(env, config());

	List<Tuple4<String, Integer, Double, String>> data = new ArrayList<>();
	data.add(new Tuple4<>("Rofl", 1, 1.0, "Hi"));
	data.add(new Tuple4<>("lol", 2, 1.0, "Hi"));
	data.add(new Tuple4<>("Test me", 4, 3.33, "Hello world"));

	Table table = tableEnv
		.fromDataSet(env.fromCollection(data), "q, w, e, r")
		.select("q as a, w as b, e as c, r as d");

	DataSet<SmallPojo2> ds = tableEnv.toDataSet(table, SmallPojo2.class);
	List<SmallPojo2> results = ds.collect();
	String expected = "Rofl,1,1.0,Hi\n" + "lol,2,1.0,Hi\n" + "Test me,4,3.33,Hello world\n";
	compareResultAsText(results, expected);
}
 

@Test
@Ignore
public void assertContend() throws Exception {
    CuratorFramework client = CuratorFrameworkFactory.newClient(EmbedTestingServer.getConnectionString(), new RetryOneTime(2000));
    client.start();
    client.blockUntilConnected();
    ZookeeperElectionService service = new ZookeeperElectionService(HOST_AND_PORT, client, ELECTION_PATH, electionCandidate);
    service.start();
    ElectionCandidate anotherElectionCandidate = mock(ElectionCandidate.class);
    CuratorFramework anotherClient = CuratorFrameworkFactory.newClient(EmbedTestingServer.getConnectionString(), new RetryOneTime(2000));
    ZookeeperElectionService anotherService = new ZookeeperElectionService("ANOTHER_CLIENT:8899", anotherClient, ELECTION_PATH, anotherElectionCandidate);
    anotherClient.start();
    anotherClient.blockUntilConnected();
    anotherService.start();
    KillSession.kill(client.getZookeeperClient().getZooKeeper(), EmbedTestingServer.getConnectionString());
    service.stop();
    verify(anotherElectionCandidate).startLeadership();
}
 

@Ignore
@Test
public void testIpSpaceSpecValidIpQuery() {
  CompletionMetadata completionMetadata = getMockCompletionMetadata();

  // Exact match first, then any addresses that contain ‘1.2.3.4’, then any operators that we can
  // provide completions for, then operators that we can’t provide completions for (we stop giving
  // suggestions if the user enters ‘:’ for an ip wildcard)
  assertThat(
      AutoCompleteUtils.autoComplete(
              "network",
              "snapshot",
              Type.IP_SPACE_SPEC,
              "1.2.3.4",
              15,
              completionMetadata,
              NodeRolesData.builder().build(),
              new ReferenceLibrary(ImmutableList.of()))
          .stream()
          .map(AutocompleteSuggestion::getText)
          .collect(ImmutableList.toImmutableList()),
      equalTo(ImmutableList.of("1.2.3.4", "11.2.3.4", "-", "/", "\\", "&", ",", ":")));
}
 

@Ignore("Fails")
@Test
public void testGReturnStmt() {
    Stmt s = Grimp.v().newReturnStmt(IntConstant.v(1));

    Set expectedRep = new ExceptionHashSet(utility.VM_ERRORS);
    expectedRep.add(utility.ILLEGAL_MONITOR_STATE_EXCEPTION);
    assertTrue(ExceptionTestUtility.sameMembers(expectedRep, Collections.EMPTY_SET,
                unitAnalysis.mightThrow(s)));

    Set expectedCatch = new ExceptionHashSet(utility.VM_ERRORS_PLUS_SUPERTYPES);
    expectedCatch.add(utility.ILLEGAL_MONITOR_STATE_EXCEPTION);
    expectedCatch.add(utility.RUNTIME_EXCEPTION);
    expectedCatch.add(utility.EXCEPTION);
    assertEquals(expectedCatch, 
            utility.catchableSubset(unitAnalysis.mightThrow(s)));
}
 

@Test
@Ignore
public void testObservableDirectoryCreateANewFileObservableIsNotifiedTwice()
        throws InterruptedException, IOException {
    final File temporaryDirectory = Files.createTempDir();

    try (DirectoryWatcherFiles directoryWatcherFiles = new DirectoryWatcherFiles(mockExecutorService,
            temporaryDirectory.toPath())) {

        final Consumer<List<File>> mockConsumer = mock(Consumer.class);
        directoryWatcherFiles.setOnChange(mockConsumer);

        File createdFile = new File(temporaryDirectory, "file.txt");
        Thread.sleep(2 * CHECK_INTERVAL);
        createdFile.createNewFile();
        Thread.sleep(10 * CHECK_INTERVAL);

        temporaryDirectory.delete();

        verify(mockConsumer, times(2)).accept(any(List.class));
    }
}
 

@Ignore("oracle驱动暂时没依赖")
@Test
public void dynamicChangeGlobalDbTypeTest() throws InterruptedException {
    Map re = tddlJT.queryForMap("select * from normaltbl_0001 where pk=?", new Object[] { RANDOM_ID });
    Assert.assertEquals(time, String.valueOf(re.get("gmt_create")));
    MockServer.setConfigInfo(TAtomConstants.getGlobalDataId(DBKEY_0),
        "ip=10.232.31.154\r\nport=3306\r\ndbName=qatest_normal_0\r\ndbType=oracle\r\ndbStatus=RW\r\n");

    TimeUnit.SECONDS.sleep(SLEEP_TIME);
    try {
        tddlJT.queryForMap("select * from normaltbl_0001 where pk=?", new Object[] { RANDOM_ID });
        MockServer.setConfigInfo(TAtomConstants.getGlobalDataId(DBKEY_0),
            "ip=10.232.31.154\r\nport=3306\r\ndbName=qatest_normal_0\r\ndbType=oracle\r\ndbStatus=RW\r\n");
        TimeUnit.SECONDS.sleep(SLEEP_TIME);
        tddlJT.queryForMap("select * from normaltbl_0001 where pk=?", new Object[] { RANDOM_ID });
        Assert.fail();
    } catch (Exception ex) {
    }
    MockServer.setConfigInfo(TAtomConstants.getGlobalDataId(DBKEY_0),
        "ip=10.232.31.154\r\nport=3306\r\ndbName=qatest_normal_0\r\ndbType=mysql\r\ndbStatus=RW\r\n");
    TimeUnit.SECONDS.sleep(SLEEP_TIME);
    re = tddlJT.queryForMap("select * from normaltbl_0001 where pk=?", new Object[] { RANDOM_ID });
    Assert.assertEquals(time, String.valueOf(re.get("gmt_create")));
}
 

@Test @Ignore
public void backpressureScheduledDelayNonBlocking(){

    captured= "";

       diff =  System.currentTimeMillis();
      Queue<String> blockingQueue = new ManyToOneConcurrentArrayQueue<String>(1);


      range(0, Integer.MAX_VALUE)
          .limit(3)
          .peek(i->System.out.println("diff before is "  +diff))
          .peek(v-> diff = System.currentTimeMillis()-diff)
          .peek(i->System.out.println("diff is "  +diff))
          .map(i -> i.toString())
          .scheduleFixedDelay(1l, scheduled)
          .connect(blockingQueue)
          .onePer(1, TimeUnit.SECONDS)
          .peek(i->System.out.println("BQ " + blockingQueue))
          .peek(System.out::println)
          .forEach(c->captured=c);

      assertThat(diff,lessThan(500l));
}
 

@Test
@Ignore
public void testCandidateWithGreaterTerm() {

  BaseState state = new EmptyState(mockRaftLog);

  RequestVote requestVote = RequestVote.newBuilder()
    .setCandidateId(candidate.toString())
    .setLastLogIndex(2)
    .setLastLogTerm(3)
    .setTerm(2)
    .build();

  Replica otherCandidate = config.getReplica("other");
  when(mockRaftLog.votedFor()).thenReturn(Optional.of(otherCandidate));
  boolean shouldVote = state.shouldVoteFor(mockRaftLog, requestVote);

  assertTrue(shouldVote);
}
 

@Ignore
@Test(expected = ConnectException.class)
public void test_NoUser() throws Throwable {
    ServiceInstance instance = new ServiceInstance();
    ArrayList<InstanceParameter> params = new ArrayList<InstanceParameter>();
    params.add(PUBLIC_IP);
    params.add(WSDL);
    params.add(PROTOCOL);
    params.add(PORT);
    instance.setInstanceParameters(params);
    try {
        getInstance(instance);
    } catch (BadResultException e) {
        throw e.getCause();
    }
}
 

@Test
@Ignore
public void testDirtyChecking() {
    doInJPA(entityManager -> {
        List<Post> posts = posts(entityManager);
        for (int i = 0; i < 100_000; i++) {
            for (Post post : posts) {
                modifyEntities(post, i);
            }
            entityManager.flush();
        }
    });

    doInJPA(entityManager -> {
        enableMetrics= true;
        List<Post> posts = posts(entityManager);
        for (int i = 0; i < iterationCount; i++) {
            for (Post post : posts) {
                modifyEntities(post, i);
            }
            entityManager.flush();
        }
        LOGGER.info("Flushed {} entities", entityCount);
        logReporter.report();
    });
}
 

/**
 * Cellの取得で認証トークンにBasic形式で不正な値を指定した場合に認証エラーが返却されること.
 * TODO V1.1 Basic認証に対応後有効化する
 */
@Test
@Ignore
public final void Cellの取得で認証トークンにBasic形式で不正な値を指定した場合に認証エラーが返却されること() {
    HashMap<String, String> headers = new HashMap<String, String>();
    // コロンを含んだ文字列ををBase64化して、ヘッダーに指定
    headers.put(HttpHeaders.AUTHORIZATION, "Basic YzNzgUZpbm5vdg==");
    this.setHeaders(headers);

    DcResponse res = this.restGet(getUrl(this.cellId));

    // ステータスコード:401
    // コンテンツタイプ:application/json
    // Etagヘッダが存在しない
    // ボディのエラーコードチェック
    assertEquals(HttpStatus.SC_UNAUTHORIZED, res.getStatusCode());
    assertEquals(MediaType.APPLICATION_JSON, res.getResponseHeaders(HttpHeaders.CONTENT_TYPE)[0].getValue());
    this.checkErrorResponse(res.bodyAsJson(), "PR401-AU-0004");
}
 

@Ignore
public void testModelSerialize2DDF() throws DDFException {
  DummyModel dummyModel = new DummyModel(20, "dummymodel2");
  Model model = new Model(dummyModel);
  DDFManager manager = DDFManager.get(DDFManager.EngineType.BASIC);

  DDF ddf = model.serialize2DDF(manager);

  Object obj = ddf.getRepresentationHandler().get(List.class, String.class);
  List<Schema.Column> cols = ddf.getSchema().getColumns();
  List<String> lsString = (List<String>) obj;

  Assert.assertTrue(obj != null);
  Assert.assertTrue(obj instanceof List);
  Assert.assertTrue(ddf != null);

  APersistenceHandler.PersistenceUri uri = ddf.persist();
  PersistenceHandler pHandler = new PersistenceHandler(null);
  DDF ddf2 = (DDF) pHandler.load(uri);
  Model model2 = Model.deserializeFromDDF((BasicDDF) ddf2);

  Assert.assertTrue(ddf2 != null);
  Assert.assertTrue(model2 != null);
  Assert.assertTrue(model2.getRawModel() instanceof DummyModel);
}
 

@Test
@Ignore(value = IgnoreReasonConstants.REAL_BROWSER)
public void realTest()
{
	util.getEngine().setDriverStr(DriverConstants.DRIVER_CHROME);
	util.getEngine().init();
	util.initData();

	AnnotationPage page = util.getPage(AnnotationPage.class);
	page.open();
	page.getToLoginBut().click();

	page.getPhoneText().fillNotBlankValue();
	page.getPasswordText().fillNotBlankValue();

	ThreadUtil.silentSleep(3000);
}
 

@Ignore
@Test
public void testPlayerMultipleOnlyVideoSeekRepositoryMp4() throws Exception {
  // Test data
  final String mediaUrl = "/video/30sec/rgbOnlyVideo.mp4";
  initTest(MONGODB, mediaUrl);
}
 

@Ignore("TODO fix me")
@Test
public void testUnambiguousStaticImports_02() {
  StringConcatenation _builder = new StringConcatenation();
  _builder.append("import static MockitoMatchers.* ");
  _builder.newLine();
  _builder.append("import static HarmcrestMatchers.*");
  _builder.newLine();
  _builder.newLine();
  _builder.append("class Bug {");
  _builder.newLine();
  _builder.append("  ");
  _builder.append("def static accept(Bug bug) {");
  _builder.newLine();
  _builder.append("    ");
  _builder.append("any(Bug)");
  _builder.newLine();
  _builder.append("  ");
  _builder.append("}");
  _builder.newLine();
  _builder.append("}");
  _builder.newLine();
  _builder.append("class MockitoMatchers {");
  _builder.newLine();
  _builder.append("\t");
  _builder.append("static def <T> Matcher<T> any(Class<T> type) {}");
  _builder.newLine();
  _builder.append("}");
  _builder.newLine();
  _builder.append("class Matcher<T> {}");
  _builder.newLine();
  _builder.append("class HarmcrestMatchers {");
  _builder.newLine();
  _builder.append("\t");
  _builder.append("static def Bug any(Class<? extends Bug> clazz) {}");
  _builder.newLine();
  _builder.append("}");
  _builder.newLine();
  this.assertUnambiguous(_builder);
}
 

@Test @Ignore
public void testPojo2EntityMySQL() {
    TesttableMySQL pojo = createMySQLPOJO();
    EntityMeta meta = DasRemoteDelegate.extract(pojo.getClass());
    List<Entity> entities = ConvertUtils.pojo2Entities(Arrays.asList(pojo), meta);
    List<Map<String, Object>> maps = ConvertUtils.entity2POJOs(entities, meta, Map.class);

    assertEquals(1, maps.size());
    Map<String, Object> map = maps.get(0);

    assertEquals(pojo.getMyID(), map.get("MyID"));
    assertEquals(pojo.getMyBit(), map.get("MyBit"));
    assertEquals(pojo.getMyTinyint(), Integer.valueOf(map.get("MyTinyint").toString()));
    assertEquals(pojo.getMySmallint(), Integer.valueOf(map.get("MySmallint").toString()));
    assertEquals(pojo.getMyMediumint(), map.get("MyMediumint"));
    assertEquals(pojo.getMyBigint(), map.get("MyBigint"));
    assertEquals(pojo.getMyDecimal(), map.get("MyDecimal"));
    assertEquals(pojo.getMyFloat(), map.get("MyFloat"));
    assertEquals(pojo.getMyDouble(), map.get("MyDouble"));
    assertEquals(pojo.getMyBool(), map.get("MyBool"));
    assertEquals(pojo.getMyDate(), map.get("MyDate"));
    assertEquals(pojo.getMyDatetime(), map.get("MyDatetime"));
    assertEquals(pojo.getMyTimestamp(), map.get("MyTimestamp"));
    assertEquals(pojo.getMyTime(), map.get("MyTime"));
    assertEquals(pojo.getMyYear(), map.get("MyYear"));
    assertEquals(pojo.getMyVarchar(), map.get("MyVarchar"));
    assertEquals(pojo.getMyChar(), map.get("MyChar"));
    assertEquals(pojo.getMyText(), map.get("MyText"));
    assertArrayEquals(pojo.getMyBinary(), (byte[]) map.get("MyBinary"));
    assertArrayEquals(pojo.getMyVarbinary(), (byte[])map.get("MyVarbinary"));
    assertArrayEquals(pojo.getMyBlob(), (byte[])map.get("MyBlob"));
}
 

@Test
@Ignore
public void testSetAcl() throws Exception {
  RepositoryDirectoryInterface rootDir = initRepo();
  JobMeta jobMeta = createJobMeta( EXP_JOB_NAME );
  RepositoryDirectoryInterface jobsDir = rootDir.findDirectory( DIR_JOBS );
  repository.save( jobMeta, VERSION_COMMENT_V1, null );
  deleteStack.push( jobMeta );
  assertNotNull( jobMeta.getObjectId() );
  ObjectRevision version = jobMeta.getObjectRevision();
  assertNotNull( version );
  assertTrue( hasVersionWithComment( jobMeta, VERSION_COMMENT_V1 ) );
  assertTrue( repository.exists( EXP_JOB_NAME, jobsDir, RepositoryObjectType.JOB ) );
  ObjectAcl acl = ( (IAclService) repository ).getAcl( jobMeta.getObjectId(), false );
  assertNotNull( acl );
  acl.setEntriesInheriting( false );
  ObjectAce ace =
      new RepositoryObjectAce( new RepositoryObjectRecipient( "suzy", Type.USER ), EnumSet
          .of( RepositoryFilePermission.READ ) );
  List<ObjectAce> aceList = new ArrayList<ObjectAce>();
  aceList.add( ace );
  acl.setAces( aceList );
  ( (IAclService) repository ).setAcl( jobMeta.getObjectId(), acl );
  ObjectAcl acl1 = ( (IAclService) repository ).getAcl( jobMeta.getObjectId(), false );
  assertEquals( Boolean.FALSE, acl1.isEntriesInheriting() );
  assertEquals( 1, acl1.getAces().size() );
  ObjectAce ace1 = acl1.getAces().get( 0 );
  assertEquals( ace1.getRecipient().getName(), "suzy" );
  assertTrue( ace1.getPermissions().contains( RepositoryFilePermission.READ ) );
}
 

@Test
@Ignore // what exactly are we testing here? as this is random ...
public void testIsReachable() throws Exception {
    final int timeout = 3000;
    final boolean reachable = InetAddress.getByName(WHOIS).isReachable(timeout);

    try (Socket socket = createSocket()) {
        InetAddress inet = socket.getInetAddress();
        assertEquals(reachable, inet.isReachable(timeout));
    }
}
 

@Ignore
@Test
public void invalidValidationObjectiveSentTest() {
	ValidationResultsDto results = runReferenceCCDAValidationServiceAndReturnResults("INVALID VALIDATION OBJECTIVE",
			HAS_4_POSSIBLE_CONSOL_AND_1_POSSIBLE_MU2_ERROR);
	final String msg = handleServiceErrorTest(results);
	final String match = "invalid";
	assertTrue("The service error returned did not contain: " + match, msg.contains(match));
}
 

@Test
@Ignore // ignored to not run this automatically.
// Run this for manual testing in its own JUnit process (right-click in IDE),
// and simultaneously run testStartClientAndSubmitExecutionRequest in a separate JUnit process...
public void testStartListener() {
    final MobilityController mobilityController = MobilityRPC.newController();
    final ConnectionManager connectionManager = mobilityController.getConnectionManager();

    final ConnectionId localEndpointIdentifier = new ConnectionId("127.0.0.1", 5739);

    connectionManager.bindConnectionListener(localEndpointIdentifier);
    sleep(10);
    connectionManager.unbindConnectionListener(localEndpointIdentifier);
}
 

@Test
@Ignore("decimal")
public void testTruncateDecimalFunction() throws Exception {
  String query = "SELECT " +
      "trunc(cast('1234.4567' as decimal(9, 5))) as DEC9_1, " +
      "trunc(cast('1234.0000' as decimal(9, 5))) as DEC9_2, " +
      "trunc(cast('-1234.4567' as decimal(9, 5))) as DEC9_3, " +
      "trunc(cast('0.111' as decimal(9, 5))) as DEC9_4, " +
      "trunc(cast('99999912399.4567' as decimal(18, 5))) DEC18_1, " +
      "trunc(cast('99999912399.0000' as decimal(18, 5))) DEC18_2, " +
      "trunc(cast('-99999912399.4567' as decimal(18, 5))) DEC18_3, " +
      "trunc(cast('-99999912399.0000' as decimal(18, 5))) DEC18_4, " +
      "trunc(cast('12345678912345678912.4567' as decimal(28, 5))) DEC28_1, " +
      "trunc(cast('999999999999999999.4567' as decimal(28, 5))) DEC28_2, " +
      "trunc(cast('12345678912345678912.0000' as decimal(28, 5))) DEC28_3, " +
      "trunc(cast('-12345678912345678912.4567' as decimal(28, 5))) DEC28_4, " +
      "trunc(cast('-12345678912345678912.0000' as decimal(28, 5))) DEC28_5, " +
      "trunc(cast('1234567891234567891234567891234567891.4' as decimal(38, 1))) DEC38_1, " +
      "trunc(cast('999999999999999999999999999999999999.4' as decimal(38, 1))) DEC38_2, " +
      "trunc(cast('1234567891234567891234567891234567891.0' as decimal(38, 1))) DEC38_3, " +
      "trunc(cast('-1234567891234567891234567891234567891.4' as decimal(38, 1))) DEC38_4, " +
      "trunc(cast('-999999999999999999999999999999999999.4' as decimal(38, 1))) DEC38_5 " +
      "FROM cp.\"tpch/region.parquet\" limit 1";

  testBuilder()
      .sqlQuery(query)
      .unOrdered()
      .baselineColumns("DEC9_1", "DEC9_2", "DEC9_3", "DEC9_4", "DEC18_1", "DEC18_2", "DEC18_3", "DEC18_4", "DEC28_1",
          "DEC28_2", "DEC28_3", "DEC28_4", "DEC28_5", "DEC38_1", "DEC38_2", "DEC38_3", "DEC38_4", "DEC38_5")
      .baselineValues(new BigDecimal("1234"), new BigDecimal("1234"), new BigDecimal("-1234"), new BigDecimal("0"),
          new BigDecimal("99999912399"), new BigDecimal("99999912399"), new BigDecimal("-99999912399"),
          new BigDecimal("-99999912399"), new BigDecimal("12345678912345678912"), new BigDecimal("999999999999999999"),
          new BigDecimal("12345678912345678912"), new BigDecimal("-12345678912345678912"), new BigDecimal("-12345678912345678912"),
          new BigDecimal("1234567891234567891234567891234567891"), new BigDecimal("999999999999999999999999999999999999"),
          new BigDecimal("1234567891234567891234567891234567891"), new BigDecimal("-1234567891234567891234567891234567891"),
          new BigDecimal("-999999999999999999999999999999999999"))
      .go();
}
 

@Ignore
@Test
public void test_Performance_01() {
	for(int i = 0; i < 2000000; i++) {
		test_01();
	}
}
 

@Test
public void aopGoUseAnnotatedSelector()
{
    Set<String> actions = new HashSet<>();
    AnnotatedClass proxy = AopGo.proxy(new AnnotatedClass())
            .aop(binder -> {
                binder.doBefore(before -> {
                    actions.add(before.getName());
                }).annotated(Ignore.class, Ignore.class);
            }).build();
    proxy.a1();
    proxy.a2();
    Assert.assertEquals(actions, MutableSet.of("a2"));
}
 

@Test
@Ignore
public void testDefaultNetworkInterfaceForIP6Address() throws Exception {
    assertEquals(InetAddress.getByName("::1"), InetAddress.getByName("::1%en0"));
    // Bug. Defaults to awdl0 on OS X
    assertEquals(((Inet6Address) InetAddress.getByName("::1")).getScopeId(),
            ((Inet6Address) InetAddress.getByName("::1%en0")).getScopeId());
}
 

@Ignore
public void testConnectDisconnectPassthroughOneToManyMPipelineDestroyPipeline() throws Exception {
  // Stabilize the memory on the KMS
  doTest(M, false, false);
  // Use the assert for checking memory
  doTest(M, false, true);
}
 

@Override
@Test
@Ignore
public void testStreamQueryPauseInBatch(TestContext ctx) {
  // TODO streaming support
  super.testStreamQueryPauseInBatch(ctx);
}
 

@Test
@Ignore
public void setImmutableTrueDiffNonText() throws Throwable {
    GetDiffFilesOptions getDiffFilesOptions = new GetDiffFilesOptions();
    getDiffFilesOptions.setImmutable(true);
    Valids valids = new Valids();
    valids.immutable = true;
    testMethod(false, valids, getDiffFilesOptions);
    getDiffFilesOptions.setDiffNonTextFiles(true);
    valids = new Valids();
    valids.immutable = true;
    valids.diffNonTextGet = true;
    testMethod(false, valids, getDiffFilesOptions);
}
 

@Ignore
@Test
public void findById_returnsMeterReading() {
	MeterReading meterReading = new MeterReading();
	meterReading.setUUID(UUID.randomUUID());

	repository.persist(meterReading);

	assertNotNull(repository.findById(meterReading.getId()));
}
 

@Ignore("need to discuss in JVA-422")
@Test
public void testNotClearSet() {
  UnitTestSwaggerUtils.testException(
      "generate swagger operation failed, org.apache.servicecomb.swagger.generator.core.schema.InvalidType:testNotClearSet",
      "java.lang.Object not support. Must be a concrete type.",
      InvalidType.class,
      "testNotClearSet");
}