try {
      try {
        throw exception;
      } catch (Throwable e) {
        throw closer.rethrow(e);
      } finally {
        closer.close();
      }
    } catch (Throwable expected) {
      assertSame(exception, expected);
    }

    assertTrue(c1.isClosed());
    assertTrue(c2.isClosed());

    assertTrue(suppressor.suppressions.isEmpty());
  }

    void testNameServiceKnown() {
        String expected = "ERR_NAM_SRVC/FMT_ERR: Format ErrorUnknown error code: 1";
        assertEquals(expected, NbtException.getErrorString(NbtException.ERR_NAM_SRVC, NbtException.FMT_ERR));
    }

    @Test
    @DisplayName("getErrorString for name service error with unknown code")
    void testNameServiceUnknown() {
        int unknown = 99;
        String expected = "ERR_NAM_SRVC/Unknown error code: 99";

        .add("Test-Instant", expected)
        .build()
    assertThat(headers["Test-Instant"]).isEqualTo("Thu, 01 Jan 1970 00:00:00 GMT")
    assertThat(headers.getInstant("Test-Instant")).isEqualTo(expected)
  }

  @Test fun setDate() {
    val expected = Date(1000)
    val headers =
      Headers
        .Builder()
        .add("testDate", Date(0L))
        .set("testDate", expected)
        .build()

    StringBuilder input = new StringBuilder();
    StringBuilder expected = new StringBuilder();
    for (int i = 256; i < 1024; i++) {
      input.append((char) i);
      expected.append("[" + i + "]");
    }
    assertThat(SIMPLE_ESCAPER.escape(input.toString())).isEqualTo(expected.toString());
  }

  public void testSurrogatePairs() {
    UnicodeEscaper e = SIMPLE_ESCAPER;

    StringBuilder input = new StringBuilder();
    StringBuilder expected = new StringBuilder();
    for (int i = 256; i < 1024; i++) {
      input.append((char) i);
      expected.append("[" + i + "]");
    }
    assertThat(SIMPLE_ESCAPER.escape(input.toString())).isEqualTo(expected.toString());
  }

  public void testSurrogatePairs() {
    UnicodeEscaper e = SIMPLE_ESCAPER;

        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));

	}

	if len(results) != 2 {
		t.Errorf("expected 2 distinct names, got %d", len(results))
	}

	var names []string
	for _, u := range results {
		names = append(names, u.Name)
	}
	sort.Strings(names)
	expected := []string{"GenericsDistinctDup", "GenericsDistinctUnique"}
	if !reflect.DeepEqual(names, expected) {
		t.Errorf("expected names %v, got %v", expected, names)
	}
}

        // This is a well-known test vector: password -> 8846F7EAEE8FB117AD06BDD830B7586C
        byte[] expected = hex("8846F7EAEE8FB117AD06BDD830B7586C");

        // Act
        byte[] actual = NtlmUtil.getNTHash(password);

        // Assert
        assertArrayEquals(expected, actual, "NT hash must match known test vector");
    }

    @Test

      List<Entry<Object, Object>> warmed = warmUp(cache);

      Set<Object> expected = new HashMap<>(cache.asMap()).keySet();
      assertThat(keys).containsExactlyElementsIn(expected);
      assertThat(keys.toArray()).asList().containsExactlyElementsIn(expected);
      assertThat(keys.toArray(new Object[0])).asList().containsExactlyElementsIn(expected);

      new EqualsTester()
          .addEqualityGroup(cache.asMap().keySet(), keys)

			if !parser.pseudo(test.pseudo, tokenize(test.operands)) {
				t.Fatalf("Wrong pseudo-instruction: %s", test.pseudo)
			}
			errorLine := buf.String()
			if test.expected != errorLine {
				t.Errorf("Unexpected error %q; expected %q", errorLine, test.expected)
			}
			buf.Reset()
		}
	}