assertFalse(r1.hashCode() == r3.hashCode());

        assertTrue(r1.equals(r2), "Expected " + r1 + " to equal " + r2);
        assertTrue(r2.equals(r1), "Expected " + r2 + " to equal " + r1);

        assertFalse(r1.equals(r3), "Expected " + r1 + " to not equal " + r3);
        assertFalse(r3.equals(r1), "Expected " + r3 + " to not equal " + r1);
    }

        .build()
    val call = client.newCall(request)
    call.timeout().timeout(250, TimeUnit.MILLISECONDS)
    assertFailsWith<IOException> {
      call.execute()
    }.also { expected ->
      assertThat(expected.message).isEqualTo("timeout")
      assertThat(call.isCanceled()).isTrue()
    }
  }

  @Test
  fun timeoutWritingRequestWithEnqueue() {
    server.enqueue(MockResponse())
    val request =

	if !errors.Is(err, untranslatedErr) {
		t.Fatalf("expected err: %v got err: %v", untranslatedErr, err)
	}

	// it should translate error when the TranslateError flag is true
	db, _ = gorm.Open(tests.DummyDialector{TranslatedErr: translatedErr}, &gorm.Config{TranslateError: true})

	err = db.AddError(untranslatedErr)
	if !errors.Is(err, translatedErr) {
		t.Fatalf("expected err: %v got err: %v", translatedErr, err)
	}
}

    private void assertArrayEquals(String[] expected, String[] actual) {
        if (expected == null && actual == null) {
            return;
        }
        assertNotNull(expected, "Expected array is null but actual is not");
        assertNotNull(actual, "Actual array is null but expected is not");
        assertEquals("Array lengths differ", expected.length, actual.length);

			if tt.expectedError != nil && err == nil {
				t.Errorf("Expected %s, got %s", tt.expectedError, err)
			}
			if tt.expectedError == nil && err != nil {
				t.Errorf("Expected %s, got %s", tt.expectedError, err)
			}
			if tt.expectedReadQuorum != actualReadQuorum {
				t.Errorf("Expected Read Quorum %d, got %d", tt.expectedReadQuorum, actualReadQuorum)
			}

      Joiner joiner, Iterable<? extends @Nullable Integer> parts, String expected) {
    assertThat(joiner.join(parts)).isEqualTo(expected);
    assertThat(joiner.join(parts.iterator())).isEqualTo(expected);

    StringBuilder sb1FromIterable = new StringBuilder().append('x');
    joiner.appendTo(sb1FromIterable, parts);
    assertThat(sb1FromIterable.toString()).isEqualTo("x" + expected);

			if !expectedListenErr {
				if listenErrs[i] != nil {
					t.Fatalf("Test %d:, listenErrs[%d] error: expected = <nil>, got = %v", testIdx+1, i, listenErrs[i])
				}
			} else if listenErrs[i] == nil {
				t.Fatalf("Test %d: listenErrs[%d]: expected = %v, got = <nil>", testIdx+1, i, expectedListenErr)
			}
		}
		if listener != nil {
			listener.Close()
		}
	}
}

    for (int n = 0; n < replacementArray.length; n++) {
      char c = (char) n;
      String expected = map.get(c);
      if (expected == null) {
        assertThat(replacementArray[n]).isNull();
      } else {
        assertThat(new String(replacementArray[n])).isEqualTo(expected);
      }
    }
  }

        .build(),
    )
    val connection = server.url("/").toUrl().openConnection()
    try {
      connection.getInputStream().read()
      fail<Unit>()
    } catch (expected: IOException) {
      // Expected.
    }
  }

  @Test
  fun responseTimeout() {
    server.enqueue(
      MockResponse
        .Builder()
        .body("ABC")
        .clearHeaders()

    Inet4Address expected = (Inet4Address) InetAddresses.forString("192.168.1.1");
    assertThat(InetAddresses.forUriString("192.168.1.1")).isEqualTo(expected);
  }

  public void testForUriStringIPv6() {
    Inet6Address expected = (Inet6Address) InetAddresses.forString("3ffe:0:0:0:0:0:0:1");
    assertThat(InetAddresses.forUriString("[3ffe:0:0:0:0:0:0:1]")).isEqualTo(expected);
  }