};
    }

    /**
     * Deserializes a byte array back to an object.
     * <p>
     * The deserialization method used depends on the configured serializer type.
     * Supported types are Kryo and JavaBin deserialization.
     * </p>
     *
     * @param bytes the byte array to deserialize
     * @return the deserialized object

	var got dataUsageCache
	err = got.deserialize(&buf)
	if err != nil {
		t.Fatal(err)
	}
	if got.Info.LastUpdate.IsZero() {
		t.Error("lastupdate not set")
	}

	if !want.Info.LastUpdate.Equal(got.Info.LastUpdate) {
		t.Fatalf("deserialize LastUpdate mismatch\nwant: %+v\ngot:  %+v", want, got)
	}
	if len(want.Cache) != len(got.Cache) {

        assertTrue(s.contains("hello"));
    }

    @Test
    @DisplayName("Should serialize and deserialize preserving message and cause")
    void testJavaSerialization() throws Exception {
        // Given
        SpnegoException original = new SpnegoException("serialize me", new IllegalArgumentException("iaex"));

        // When
        byte[] bytes;

        SsoLoginException originalException = new SsoLoginException(message, cause);

        // Serialize the exception
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(baos);
        oos.writeObject(originalException);
        oos.close();

        // Deserialize the exception
        ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());

        DictionaryExpiredException deserialized = (DictionaryExpiredException) ois.readObject();
        ois.close();

        // Verify
        assertNotNull(deserialized);
        assertNull(deserialized.getMessage());
        assertNull(deserialized.getCause());
    }

    public void test_stackTrace() {
        // Test that stack trace is properly maintained

					case InsufficientReadQuorum, StorageErr:
						return true, nil
					}
					return false, err
				}
				err = d.deserialize(r)
				r.Close()
				return err != nil, nil
			case InsufficientReadQuorum, StorageErr:
				return true, nil
			}
			return false, err
		}
		err = d.deserialize(r)
		r.Close()
		return err != nil, nil
	}

	// Caches are read+written without locks,
	retries := 0

        SmbOperationException deserialized = (SmbOperationException) ois.readObject();
        ois.close();

        // Then
        assertNotNull(deserialized);
        assertEquals(exception.getErrorCode(), deserialized.getErrorCode());
        assertEquals(exception.getMessage(), deserialized.getMessage());
        assertEquals(exception.getContext().get("key1"), deserialized.getContext().get("key1"));

                            });
                            return result.toArray(n -> new RequestParameter[n]);
                        } catch (final Exception e) {
                            logger.warn("Failed to deserialize search parameters from cookie.", e);
                            return new RequestParameter[0];
                        }
                    }
                }
            }

    } catch (IOException e) {
      throw e;
    } catch (Exception e) { // sneaky checked exception
      String message =
          "Unable to deserialize BloomFilter from InputStream."
              + " strategyOrdinal: "
              + strategyOrdinal
              + " numHashFunctions: "
              + numHashFunctions
              + " dataLength: "

		if err != nil {
			return keys, err
		}
	}
	return keys, nil
}

// serialize will serialize the provided keys and values.
// The function will panic if keys/value slices aren't of equal length.
// Payload size can give an indication of expected payload size.
// If plSize is <= 0 it will be calculated.
func (x *xlMetaInlineData) serialize(plSize int, keys [][]byte, vals [][]byte) {
	if len(keys) != len(vals) {