runtime/lambda_proxy_test.cc

/*
 * Copyright (C) 2015 The Android Open Source Project
 *
 * 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.
 */

#include <jni.h>
#include <vector>

#include "art_field-inl.h"
#include "class_linker-inl.h"
#include "compiler_callbacks.h"
#include "common_compiler_test.h"
#include "mirror/field-inl.h"
#include "mirror/lambda_proxy.h"
#include "mirror/method.h"
#include "scoped_thread_state_change.h"

namespace art {

// The enclosing class of all the interfaces used by this test.
// -- Defined as a macro to allow for string concatenation.
#define TEST_INTERFACE_ENCLOSING_CLASS_NAME "LambdaInterfaces"
// Generate out "LLambdaInterfaces$<<iface>>;" , replacing <<iface>> with the interface name.
#define MAKE_TEST_INTERFACE_NAME(iface) ("L" TEST_INTERFACE_ENCLOSING_CLASS_NAME "$" iface ";")

#define ASSERT_NOT_NULL(x) ASSERT_TRUE((x) != nullptr)
#define ASSERT_NULL(x) ASSERT_TRUE((x) == nullptr)
#define EXPECT_NULL(x) EXPECT_TRUE((x) == nullptr)

class LambdaProxyTest  // : public CommonCompilerTest {
    : public CommonRuntimeTest {
 public:
  // Generate a lambda proxy class with the given name and interfaces. This is a simplification from what
  // libcore does to fit to our test needs. We do not check for duplicated interfaces or methods and
  // we do not declare exceptions.
  mirror::Class* GenerateProxyClass(ScopedObjectAccess& soa,
                                    jobject jclass_loader,
                                    const char* class_name,
                                    const std::vector<mirror::Class*>& interfaces)
      SHARED_REQUIRES(Locks::mutator_lock_) {
    CHECK(class_name != nullptr);
    CHECK(jclass_loader != nullptr);

    mirror::Class* java_lang_object =
        class_linker_->FindSystemClass(soa.Self(), "Ljava/lang/Object;");
    CHECK(java_lang_object != nullptr);

    jclass java_lang_class = soa.AddLocalReference<jclass>(mirror::Class::GetJavaLangClass());

    // Builds the interfaces array.
    jobjectArray proxy_class_interfaces = soa.Env()->NewObjectArray(interfaces.size(),
                                                                    java_lang_class,
                                                                    nullptr);  // No initial element.
    soa.Self()->AssertNoPendingException();
    for (size_t i = 0; i < interfaces.size(); ++i) {
      soa.Env()->SetObjectArrayElement(proxy_class_interfaces,
                                       i,
                                       soa.AddLocalReference<jclass>(interfaces[i]));
    }

    // Builds the method array.
    jsize methods_count = 3;  // Object.equals, Object.hashCode and Object.toString.
    for (mirror::Class* interface : interfaces) {
      methods_count += interface->NumVirtualMethods();
    }
    jobjectArray proxy_class_methods =
        soa.Env()->NewObjectArray(methods_count,
                                  soa.AddLocalReference<jclass>(mirror::Method::StaticClass()),
                                  nullptr);  // No initial element.
    soa.Self()->AssertNoPendingException();

    jsize array_index = 0;

    //
    // Fill the method array with the Object and all the interface's virtual methods.
    //

    // Add a method to 'proxy_class_methods'
    auto add_method_to_array = [&](ArtMethod* method) SHARED_REQUIRES(Locks::mutator_lock_) {
      CHECK(method != nullptr);
      soa.Env()->SetObjectArrayElement(proxy_class_methods,
                                       array_index++,
                                       soa.AddLocalReference<jobject>(
                                           mirror::Method::CreateFromArtMethod(soa.Self(),
                                                                               method))
                                      );  // NOLINT: [whitespace/parens] [2]

      LOG(DEBUG) << "Add " << PrettyMethod(method) << " to list of methods to generate proxy";
    };
    // Add a method to 'proxy_class_methods' by looking it up from java.lang.Object
    auto add_method_to_array_by_lookup = [&](const char* name, const char* method_descriptor)
        SHARED_REQUIRES(Locks::mutator_lock_) {
      ArtMethod* method = java_lang_object->FindDeclaredVirtualMethod(name,
                                                                      method_descriptor,
                                                                      sizeof(void*));
      add_method_to_array(method);
    };

    // Add all methods from Object.
    add_method_to_array_by_lookup("equals",   "(Ljava/lang/Object;)Z");
    add_method_to_array_by_lookup("hashCode", "()I");
    add_method_to_array_by_lookup("toString", "()Ljava/lang/String;");

    // Now adds all interfaces virtual methods.
    for (mirror::Class* interface : interfaces) {
      mirror::Class* next_class = interface;
      do {
        for (ArtMethod& method : next_class->GetVirtualMethods(sizeof(void*))) {
          add_method_to_array(&method);
        }
        next_class = next_class->GetSuperClass();
      } while (!next_class->IsObjectClass());
      // Skip adding any methods from "Object".
    }
    CHECK_EQ(array_index, methods_count);

    // Builds an empty exception array.
    jobjectArray proxy_class_throws = soa.Env()->NewObjectArray(0 /* length */,
                                                                java_lang_class,
                                                                nullptr /* initial element*/);
    soa.Self()->AssertNoPendingException();

    bool already_exists;
    mirror::Class* proxy_class =
        class_linker_->CreateLambdaProxyClass(soa,
                                              soa.Env()->NewStringUTF(class_name),
                                              proxy_class_interfaces,
                                              jclass_loader,
                                              proxy_class_methods,
                                              proxy_class_throws,
                                              /*out*/&already_exists);

    CHECK(!already_exists);

    soa.Self()->AssertNoPendingException();
    return proxy_class;
  }

  LambdaProxyTest() {
  }

  virtual void SetUp() {
    CommonRuntimeTest::SetUp();
  }

  virtual void SetUpRuntimeOptions(RuntimeOptions* options ATTRIBUTE_UNUSED) {
    // Do not have any compiler options because we don't want to run as an AOT
    // (In particular the lambda proxy class generation isn't currently supported for AOT).
    this->callbacks_.reset();
  }

  template <typename THandleScope>
  Handle<mirror::Class> GenerateProxyClass(THandleScope& hs,
                                           const char* name,
                                           const std::vector<mirror::Class*>& interfaces)
      SHARED_REQUIRES(Locks::mutator_lock_) {
    return hs.NewHandle(GenerateProxyClass(*soa_, jclass_loader_, name, interfaces));
  }

 protected:
  ScopedObjectAccess* soa_ = nullptr;
  jobject jclass_loader_ = nullptr;
};

// Creates a lambda proxy class and check ClassHelper works correctly.
TEST_F(LambdaProxyTest, ProxyClassHelper) {
  // gLogVerbosity.class_linker = true;  // Uncomment to enable class linker logging.

  ASSERT_NOT_NULL(Thread::Current());

  ScopedObjectAccess soa(Thread::Current());
  soa_ = &soa;

  // Must happen after CommonRuntimeTest finishes constructing the runtime.
  jclass_loader_ = LoadDex(TEST_INTERFACE_ENCLOSING_CLASS_NAME);
  jobject jclass_loader = jclass_loader_;

  StackHandleScope<4> hs(soa.Self());
  Handle<mirror::ClassLoader> class_loader(
      hs.NewHandle(soa.Decode<mirror::ClassLoader*>(jclass_loader)));

  Handle<mirror::Class> J(hs.NewHandle(
      class_linker_->FindClass(soa.Self(), MAKE_TEST_INTERFACE_NAME("J"), class_loader)));
  ASSERT_TRUE(J.Get() != nullptr);

  std::vector<mirror::Class*> interfaces;
  interfaces.push_back(J.Get());
  Handle<mirror::Class> proxy_class(hs.NewHandle(
      GenerateProxyClass(soa, jclass_loader, "$Proxy1234", interfaces)));
  interfaces.clear();  // Don't least possibly stale objects in the array as good practice.
  ASSERT_TRUE(proxy_class.Get() != nullptr);
  ASSERT_TRUE(proxy_class->IsLambdaProxyClass());
  ASSERT_TRUE(proxy_class->IsInitialized());

  EXPECT_EQ(1U, proxy_class->NumDirectInterfaces());  // LambdaInterfaces$J.
  EXPECT_EQ(J.Get(), mirror::Class::GetDirectInterface(soa.Self(), proxy_class, 0));
  std::string temp;
  const char* proxy_class_descriptor = proxy_class->GetDescriptor(&temp);
  EXPECT_STREQ("L$Proxy1234;", proxy_class_descriptor);
  EXPECT_EQ(nullptr, proxy_class->GetSourceFile());

  // Make sure all the virtual methods are marked as a proxy
  for (ArtMethod& method : proxy_class->GetVirtualMethods(sizeof(void*))) {
    SCOPED_TRACE(PrettyMethod(&method, /* with_signature */true));
    EXPECT_TRUE(method.IsProxyMethod());
    EXPECT_TRUE(method.IsLambdaProxyMethod());
    EXPECT_FALSE(method.IsReflectProxyMethod());
  }
}

// Creates a proxy class and check FieldHelper works correctly.
TEST_F(LambdaProxyTest, ProxyFieldHelper) {
  // gLogVerbosity.class_linker = true;  // Uncomment to enable class linker logging.

  ASSERT_NOT_NULL(Thread::Current());

  ScopedObjectAccess soa(Thread::Current());
  soa_ = &soa;

  // Must happen after CommonRuntimeTest finishes constructing the runtime.
  jclass_loader_ = LoadDex(TEST_INTERFACE_ENCLOSING_CLASS_NAME);
  jobject jclass_loader = jclass_loader_;

  StackHandleScope<9> hs(soa.Self());
  Handle<mirror::ClassLoader> class_loader(
      hs.NewHandle(soa.Decode<mirror::ClassLoader*>(jclass_loader)));

  Handle<mirror::Class> I(hs.NewHandle(
      class_linker_->FindClass(soa.Self(), MAKE_TEST_INTERFACE_NAME("I"), class_loader)));
  ASSERT_NOT_NULL(I.Get());

  // Create the lambda proxy which implements interfaces "I".
  Handle<mirror::Class> proxy_class = GenerateProxyClass(hs,
                                                         "$Proxy1234",
                                                         { I.Get() });  // Interfaces.

  ASSERT_NOT_NULL(proxy_class.Get());
  EXPECT_TRUE(proxy_class->IsLambdaProxyClass());
  EXPECT_TRUE(proxy_class->IsInitialized());
  EXPECT_NULL(proxy_class->GetIFieldsPtr());

  LengthPrefixedArray<ArtField>* static_fields = proxy_class->GetSFieldsPtr();
  ASSERT_NOT_NULL(static_fields);

  // Must have "throws" and "interfaces" static fields.
  ASSERT_EQ(+mirror::LambdaProxy::kStaticFieldCount, proxy_class->NumStaticFields());

  static constexpr const char* kInterfacesClassName = "[Ljava/lang/Class;";
  static constexpr const char* kThrowsClassName     = "[[Ljava/lang/Class;";

  // Class for "interfaces" field.
  Handle<mirror::Class> interfaces_field_class =
      hs.NewHandle(class_linker_->FindSystemClass(soa.Self(), kInterfacesClassName));
  ASSERT_NOT_NULL(interfaces_field_class.Get());

  // Class for "throws" field.
  Handle<mirror::Class> throws_field_class =
      hs.NewHandle(class_linker_->FindSystemClass(soa.Self(), kThrowsClassName));
  ASSERT_NOT_NULL(throws_field_class.Get());

  // Helper to test the static fields for correctness.
  auto test_static_field = [&](size_t index,
                               const char* field_name,
                               Handle<mirror::Class>& handle_class,
                               const char* class_name)
      SHARED_REQUIRES(Locks::mutator_lock_) {
    ArtField* field = &static_fields->At(index);
    EXPECT_STREQ(field_name, field->GetName());
    EXPECT_STREQ(class_name, field->GetTypeDescriptor());
    EXPECT_EQ(handle_class.Get(), field->GetType</*kResolve*/true>())
        << "Expected: " << PrettyClass(interfaces_field_class.Get()) << ", "
        << "Actual: " << PrettyClass(field->GetType</*kResolve*/true>()) << ", "
        << "field_name: " << field_name;
    std::string temp;
    EXPECT_STREQ("L$Proxy1234;", field->GetDeclaringClass()->GetDescriptor(&temp));
    EXPECT_FALSE(field->IsPrimitiveType());
  };

  // Test "Class[] interfaces" field.
  test_static_field(mirror::LambdaProxy::kStaticFieldIndexInterfaces,
                    "interfaces",
                    interfaces_field_class,
                    kInterfacesClassName);

  // Test "Class[][] throws" field.
  test_static_field(mirror::LambdaProxy::kStaticFieldIndexThrows,
                    "throws",
                    throws_field_class,
                    kThrowsClassName);
}

// Creates two proxy classes and check the art/mirror fields of their static fields.
TEST_F(LambdaProxyTest, CheckArtMirrorFieldsOfProxyStaticFields) {
  // gLogVerbosity.class_linker = true;  // Uncomment to enable class linker logging.

  ASSERT_NOT_NULL(Thread::Current());

  ScopedObjectAccess soa(Thread::Current());
  soa_ = &soa;

  // Must happen after CommonRuntimeTest finishes constructing the runtime.
  jclass_loader_ = LoadDex(TEST_INTERFACE_ENCLOSING_CLASS_NAME);
  jobject jclass_loader = jclass_loader_;

  StackHandleScope<8> hs(soa.Self());
  Handle<mirror::ClassLoader> class_loader(
      hs.NewHandle(soa.Decode<mirror::ClassLoader*>(jclass_loader)));

  Handle<mirror::Class> proxyClass0;
  Handle<mirror::Class> proxyClass1;
  {
    Handle<mirror::Class> L(hs.NewHandle(
        class_linker_->FindClass(soa.Self(), MAKE_TEST_INTERFACE_NAME("L"), class_loader)));
    ASSERT_TRUE(L.Get() != nullptr);

    std::vector<mirror::Class*> interfaces = { L.Get() };
    proxyClass0 = hs.NewHandle(GenerateProxyClass(soa, jclass_loader, "$Proxy0", interfaces));
    proxyClass1 = hs.NewHandle(GenerateProxyClass(soa, jclass_loader, "$Proxy1", interfaces));
  }

  ASSERT_TRUE(proxyClass0.Get() != nullptr);
  ASSERT_TRUE(proxyClass0->IsLambdaProxyClass());
  ASSERT_TRUE(proxyClass0->IsInitialized());
  ASSERT_TRUE(proxyClass1.Get() != nullptr);
  ASSERT_TRUE(proxyClass1->IsLambdaProxyClass());
  ASSERT_TRUE(proxyClass1->IsInitialized());

  LengthPrefixedArray<ArtField>* static_fields0 = proxyClass0->GetSFieldsPtr();
  ASSERT_TRUE(static_fields0 != nullptr);
  ASSERT_EQ(2u, static_fields0->size());
  LengthPrefixedArray<ArtField>* static_fields1 = proxyClass1->GetSFieldsPtr();
  ASSERT_TRUE(static_fields1 != nullptr);
  ASSERT_EQ(2u, static_fields1->size());

  EXPECT_EQ(static_fields0->At(0).GetDeclaringClass(), proxyClass0.Get());
  EXPECT_EQ(static_fields0->At(1).GetDeclaringClass(), proxyClass0.Get());
  EXPECT_EQ(static_fields1->At(0).GetDeclaringClass(), proxyClass1.Get());
  EXPECT_EQ(static_fields1->At(1).GetDeclaringClass(), proxyClass1.Get());

  Handle<mirror::Field> field00 =
      hs.NewHandle(mirror::Field::CreateFromArtField(soa.Self(), &static_fields0->At(0), true));
  Handle<mirror::Field> field01 =
      hs.NewHandle(mirror::Field::CreateFromArtField(soa.Self(), &static_fields0->At(1), true));
  Handle<mirror::Field> field10 =
      hs.NewHandle(mirror::Field::CreateFromArtField(soa.Self(), &static_fields1->At(0), true));
  Handle<mirror::Field> field11 =
      hs.NewHandle(mirror::Field::CreateFromArtField(soa.Self(), &static_fields1->At(1), true));
  EXPECT_EQ(field00->GetArtField(), &static_fields0->At(0));
  EXPECT_EQ(field01->GetArtField(), &static_fields0->At(1));
  EXPECT_EQ(field10->GetArtField(), &static_fields1->At(0));
  EXPECT_EQ(field11->GetArtField(), &static_fields1->At(1));
}

// TODO: make sure there's a non-abstract implementation of the single-abstract-method on the class.

}  // namespace art