Back to Repositories

Testing UnsafeAllocator Instance Creation Behavior in google/gson

This test suite validates the UnsafeAllocator’s instantiation behavior in Google’s Gson library, focusing on different class types including interfaces, abstract classes, and concrete classes. The tests ensure proper handling of instantiation attempts and error conditions.

Test Coverage Overview

The test suite provides comprehensive coverage of UnsafeAllocator’s instantiation capabilities across different Java class types. Key test scenarios include:

Interface instantiation validation
Abstract class instantiation handling
Concrete class instantiation verification
Error message validation for non-instantiable types

Implementation Analysis

The testing approach utilizes JUnit 4 framework with Google Truth assertions for enhanced readability and error reporting. The tests employ a systematic pattern of verifying both positive and negative scenarios, using assertThrows for exception validation and assertThat for result verification.

Technical Details

Testing tools and configuration:

JUnit 4 test framework
Google Truth assertion library
UnsafeAllocator.INSTANCE singleton usage
Custom test classes (Interface, AbstractClass, ConcreteClass)

Best Practices Demonstrated

The test suite demonstrates several testing best practices:

Clear test method naming conventions
Comprehensive documentation with detailed test purposes
Proper exception handling and verification
Isolated test cases for each scenario
Effective use of assertion libraries for readable tests

google/gson

gson/src/test/java/com/google/gson/internal/UnsafeAllocatorInstantiationTest.java

            
/*
 * Copyright (C) 2016 Google Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package com.google.gson.internal;

import static com.google.common.truth.Truth.assertThat;
import static org.junit.Assert.assertThrows;

import org.junit.Test;

/**
 * Test unsafe allocator instantiation
 *
 * @author Ugljesa Jovanovic
 */
public final class UnsafeAllocatorInstantiationTest {

  public interface Interface {}

  public abstract static class AbstractClass {}

  public static class ConcreteClass {}

  /** Ensure that an {@link AssertionError} is thrown when trying to instantiate an interface */
  @Test
  public void testInterfaceInstantiation() {
    AssertionError e =
        assertThrows(
            AssertionError.class, () -> UnsafeAllocator.INSTANCE.newInstance(Interface.class));

    assertThat(e).hasMessageThat().startsWith("UnsafeAllocator is used for non-instantiable type");
  }

  /**
   * Ensure that an {@link AssertionError} is thrown when trying to instantiate an abstract class
   */
  @Test
  public void testAbstractClassInstantiation() {
    AssertionError e =
        assertThrows(
            AssertionError.class, () -> UnsafeAllocator.INSTANCE.newInstance(AbstractClass.class));

    assertThat(e).hasMessageThat().startsWith("UnsafeAllocator is used for non-instantiable type");
  }

  /** Ensure that no exception is thrown when trying to instantiate a concrete class */
  @Test
  public void testConcreteClassInstantiation() throws Exception {
    ConcreteClass instance = UnsafeAllocator.INSTANCE.newInstance(ConcreteClass.class);
    assertThat(instance).isNotNull();
  }
}