// Collect large allocation stats.
	totalAlloc := consStats.largeAlloc
	nMalloc := consStats.largeAllocCount
	totalFree := consStats.largeFree
	nFree := consStats.largeFreeCount

	// Collect per-sizeclass stats.
	var bySize [_NumSizeClasses]struct {
		Size    uint32
		Mallocs uint64
		Frees   uint64
	}
	for i := range bySize {
		bySize[i].Size = uint32(class_to_size[i])

		// Malloc stats.

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.api.internal.tasks.compile.incremental.test;

import java.util.*;

public class SomeClass {

    List<Integer> field = new LinkedList<Integer>();

    private AccessedFromPrivateField accessedFromPrivateField;

    AccessedFromPackagePrivateField someField;

package org.gradle;

Michael Anthony Knyszek <******@****.***> 1716237096 +0000

 * either express or implied. See the License for the specific language
 * governing permissions and limitations under the License.
 */
package org.codelibs.core.lang;

import static org.codelibs.core.TestUtil.sameClass;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.CoreMatchers.not;
import static org.hamcrest.CoreMatchers.nullValue;
import static org.junit.Assert.assertThat;

import java.lang.reflect.Method;

        assertThat(pd.getKeyClassOfMap(), is(sameClass(String.class)));
        assertThat(pd.getValueClassOfMap(), is(sameClass(Date.class)));

        ParameterizedClassDesc pcd = pd.getParameterizedClassDesc();
        assertThat(pcd.getRawClass(), is(sameClass(Map.class)));
        assertThat(pcd.getArguments().length, is(2));
        assertThat(pcd.getArguments()[0].getRawClass(), is(sameClass(String.class)));

        assertThat(desc.getRawClass(), is(sameClass(Set.class)));
        ParameterizedClassDesc[] args = desc.getArguments();
        assertThat(args.length, is(1));
        assertThat(args[0].getRawClass(), is(sameClass(Integer.class)));

        desc = ParameterizedClassDescFactory.createParameterizedClassDesc(method, 1, map);
        assertThat(desc.getRawClass(), is(sameClass(Map.class)));
        args = desc.getArguments();

    def "loads class once and caches result"() {
        when:
        def cl = classLoader.loadClass("someClass")

        then:
        cl == String.class

        and:
        1 * parent.loadClass("someClass", false) >> String.class
        0 * parent._

        when:
        cl = classLoader.loadClass("someClass")

        then:
        cl == String.class

        and:
        0 * parent._
    }

        assertThat(parameterizedClassDesc.isParameterizedClass(), is(true));
        assertThat(parameterizedClassDesc.getRawClass(), is(sameClass(Class.class)));
        final MyBean myBean = new MyBean();
        aaa.setFieldValue(myBean, String.class);
        assertThat(aaa.getFieldValue(myBean), is(sameClass(String.class)));
    }

    /**
     * @throws Exception
     */
    @Test(expected = FieldNotStaticRuntimeException.class)

// FIR test. It will be fixed by KT-63221.

class SomeClass

fun someFun(): Int {
    return 5
}

@Suppress("CONFLICTING_OVERLOADS")
fun someFun(): SomeClass {
    return SomeClass()
}

@Suppress("CONFLICTING_OVERLOADS")
fun someFun() {
}

fun someFun(): String {
    return ""