}
    assertEquals(expected, builder.toString());
    assertFullyRead(reader);

    // read all to one CharBuffer
    reader = new CharSequenceReader(charSequence);
    CharBuffer buf2 = CharBuffer.allocate(expected.length());
    assertEquals(expected.length() == 0 ? -1 : expected.length(), reader.read(buf2));
    Java8Compatibility.flip(buf2);
    assertEquals(expected, buf2.toString());

          expected[b][i] = expected[b][bit] ^ expected[b][i ^ bit];
        }
      }
    }

    int[][] actual = Crc32cHashFunction.Crc32cHasher.STRIDE_TABLE;
    assertTrue(
        "Expected: \n"
            + Arrays.deepToString(expected)
            + "\nActual:\n"
            + Arrays.deepToString(actual),
        Arrays.deepEquals(expected, actual));
  }

          public @Nullable Object getIfPresent(Object key) {
            return valueRef.get();
          }
        };

    UncheckedExecutionException expected =
        assertThrows(UncheckedExecutionException.class, () -> cache.getUnchecked(new Object()));
    assertThat(expected).hasCauseThat().isEqualTo(cause);

    Object newValue = new Object();
    valueRef.set(newValue);
    assertSame(newValue, cache.getUnchecked(new Object()));

		expectErr := (err != nil)

		if expectErr != testCase.expectErr {
			t.Fatalf("test %v: error: expected: %v, got: %v", i+1, testCase.expectErr, expectErr)
		}

		if !testCase.expectErr {
			if !reflect.DeepEqual(data, testCase.expectedData) {
				t.Fatalf("test %v: data: expected: %v, got: %v", i+1, string(testCase.expectedData), string(data))
			}
		}
	}
}

        assertEquals(c1.hashCode(), c2.hashCode(), "expected same hashcode for " + v1 + " and " + v2);
        assertEquals(c1, c2, "expected " + v1 + ".equals( " + v2 + " )");
        assertEquals(c2, c1, "expected " + v2 + ".equals( " + v1 + " )");
    }

    private void checkVersionsHaveSameOrder(String v1, String v2) {
        ComparableVersion c1 = new ComparableVersion(v1);

   * of throwable.
   */
  public void callAndAssertThrows(
      Class<? extends Throwable> expected, String methodName, Object... arguments)
      throws Exception {
    checkNotNull(expected);
    checkNotNull(methodName);
    checkNotNull(arguments);
    sendRequest(methodName, arguments);
    assertEquals(expected, getResponse(methodName).getThrowable().getClass());
  }

  /**

      }
      assertEqualsUsingStartedWith(perm, expected, elements);
    }
  }

  /** Regression test for b/4124577 */
  public void testRegression_dataCorruption() {
    int size = 8;
    List<Integer> expected = createOrderedList(size);
    MinMaxPriorityQueue<Integer> q = MinMaxPriorityQueue.create(expected);
    List<Integer> contents = Lists.newArrayList(expected);

		t.Errorf("Expected the Version to be \"%s\", but got \"%s\".", unMarshalXLMeta.Version, jsoniterXLMeta.Version)
	}
	if unMarshalXLMeta.Format != jsoniterXLMeta.Format {
		t.Errorf("Expected the format to be \"%s\", but got \"%s\".", unMarshalXLMeta.Format, jsoniterXLMeta.Format)
	}
	if unMarshalXLMeta.Stat.Size != jsoniterXLMeta.Stat.Size {

			if len(gotFields) != len(test.expectedFields) {
				t.Errorf("Expected keys %d, found %d", len(test.expectedFields), len(gotFields))
			}
			found := true
			for _, field := range gotFields {
				_, ok := test.expectedFields[field]
				found = found && ok
			}
			if !found {
				t.Errorf("Expected %s, got %s", test.expectedFields, gotFields)
			}
		})
	}
}

        String host = "www.codelibs.org";
        String expected = "www.codelibs.org";
        assertEquals(expected, resolver.toAscii(host));

        host = "テスト.org";
        expected = "xn--zckzah.org";
        assertEquals(expected, resolver.toAscii(host));

        host = "xn--zckzah.org";
        expected = "xn--zckzah.org";
        assertEquals(expected, resolver.toAscii(host));