},
	}
	for i, tc := range testCases {
		actual, err := parseRestoreObjStatus(tc.restoreHdr)
		if err != tc.expectedErr {
			t.Fatalf("Test %d: got %v expected %v", i+1, err, tc.expectedErr)
		}
		if actual != tc.expectedStatus {
			t.Fatalf("Test %d: got %v expected %v", i+1, actual, tc.expectedStatus)
		}
	}
}

// TestRestoreObjStatusRoundTrip restoreObjStatus roundtrip
func TestRestoreObjStatusRoundTrip(t *testing.T) {

      assertWrapsInterruptedException(expected);
    } finally {
      interruptenator.shutdown();
      Thread.interrupted();
    }
  }

  public void testAwaitDone_future_interrupted_interrupted() {
    Interruptenator interruptenator = new Interruptenator(Thread.currentThread());
    try {
      SettableFuture<@Nullable Void> future = SettableFuture.create();
      RuntimeException expected =

    clientListener.assertOpen()
    val reason = repeat('X', 124)
    assertFailsWith<IllegalArgumentException> {
      webSocket.close(1000, reason)
    }.also { expected ->
      assertThat(expected.message).isEqualTo("reason.size() > 123: $reason")
    }
    webSocket.close(1000, null)
    serverListener.assertClosing(1000, "")
    server.close(1000, null)

      }
    }
  }

  public void testFactorial() {
    BigInteger expected = BigInteger.ONE;
    for (int i = 1; i <= 200; i++) {
      expected = expected.multiply(BigInteger.valueOf(i));
      assertEquals(expected, BigIntegerMath.factorial(i));
    }
  }

  public void testFactorial0() {
    assertEquals(BigInteger.ONE, BigIntegerMath.factorial(0));

      }
      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 = new ArrayList<>(expected);

        String expectedMessage = "Invalid string length, expected 5, have 8";
        assertEquals(expectedMessage, exception.getMessage(), "The exception message is not correct.");
    }

    /**
     * Tests the {@link PacUnicodeString#check(String)} method with an empty string.
     *
     * @throws PACDecodingException if the check fails, which is not expected in this test.
     */
    @Test

    assertEquals(
        "put(present, value) should return the associated value",
        getValueForNullKey(),
        put(newEntry));

    Entry<K, V>[] expected = createArrayWithNullKey();
    expected[getNullLocation()] = newEntry;
    expectContents(expected);
  }

  @MapFeature.Require(value = SUPPORTS_PUT, absent = ALLOWS_NULL_KEYS)
  public void testPut_nullKeyUnsupported() {

  @Test
  fun onePartRequired() {
    assertFailsWith<IllegalStateException> {
      MultipartBody.Builder().build()
    }.also { expected ->
      assertThat(expected.message)
        .isEqualTo("Multipart body must have at least one part.")
    }
  }

  @Test
  fun singlePart() {
    val expected =
      """
      |--123
      |
      |Hello, World!
      |--123--
      |

            return expected;
          }
        };

    AsyncCallable<String> asyncCallable =
        Callables.asAsyncCallable(callable, newDirectExecutorService());

    ListenableFuture<String> future = asyncCallable.call();
    assertSame(expected, future.get());
  }

  @J2ktIncompatible
  @GwtIncompatible
  public void testAsAsyncCallable_exception() throws Exception {

        try {
            validator.validateBuffer(null, 50, 200); // Will fail
        } catch (SmbException e) {
            // Expected
        }

        try {
            validator.safeAdd(Integer.MAX_VALUE, 1); // Will fail
        } catch (SmbException e) {
            // Expected
        }

        stats = validator.getStats();
        assertTrue(stats.getTotalValidations() > 0);