TestJava.cpp

// Copyright (c) 2013-2015 Josh Blum
//                    2019 Nicholas Corgan
// SPDX-License-Identifier: BSL-1.0

#include "JavaProxy.hpp"

#include <Pothos/Testing.hpp>
#include <Pothos/Framework.hpp>
#include <Pothos/Proxy.hpp>
#include <iostream>
#include <vector>
#include <cstdlib>
#include <sstream>

POTHOS_TEST_BLOCK("/proxy/java/tests", test_basic_types)
{
    auto env = Pothos::ProxyEnvironment::make("java");

    auto noneProxy = env->convertObjectToProxy(Pothos::Object());
    auto nullObject = env->convertProxyToObject(noneProxy);
    POTHOS_TEST_TRUE(not nullObject);

    POTHOS_TEST_EQUAL(env->makeProxy(true).convert<bool>(), true);
    POTHOS_TEST_EQUAL(env->makeProxy(false).convert<bool>(), false);

    const char charVal = char((std::rand()-RAND_MAX/2)/(RAND_MAX >> 8));
    POTHOS_TEST_EQUAL(env->makeProxy(charVal).convert<char>(), charVal);

    const short shortVal = short((std::rand()-RAND_MAX/2));
    POTHOS_TEST_EQUAL(env->makeProxy(shortVal).convert<short>(), shortVal);

    const int intVal = int(std::rand()-RAND_MAX/2);
    POTHOS_TEST_EQUAL(env->makeProxy(intVal).convert<int>(), intVal);

    const long longVal = long(std::rand()-RAND_MAX/2);
    POTHOS_TEST_EQUAL(env->makeProxy(longVal).convert<long>(), longVal);

    const long long llongVal = (long long)(std::rand()-RAND_MAX/2);
    POTHOS_TEST_EQUAL(env->makeProxy(llongVal).convert<long long>(), llongVal);

    const float floatVal = float(std::rand()-RAND_MAX/2);
    POTHOS_TEST_EQUAL(env->makeProxy(floatVal).convert<float>(), floatVal);

    const double doubleVal = double(std::rand()-RAND_MAX/2);
    POTHOS_TEST_EQUAL(env->makeProxy(doubleVal).convert<double>(), doubleVal);

    const std::string strVal = "Hello World!";
    POTHOS_TEST_EQUAL(env->makeProxy(strVal).convert<std::string>(), strVal);
}

POTHOS_TEST_BLOCK("/proxy/java/tests", test_compare_to)
{
    auto env = Pothos::ProxyEnvironment::make("java");

    auto int0 = env->makeProxy(0);
    auto int1 = env->makeProxy(1);
    auto int2 = env->makeProxy(2);

    //test compare less, greater...
    POTHOS_TEST_TRUE(int0 < int1);
    POTHOS_TEST_TRUE(int0 < int2);
    POTHOS_TEST_TRUE(int1 < int2);
    POTHOS_TEST_TRUE(int0 < int2);

    POTHOS_TEST_TRUE(int1 > int0);
    POTHOS_TEST_TRUE(int2 > int0);
    POTHOS_TEST_TRUE(int2 > int1);
    POTHOS_TEST_TRUE(int2 > int0);

    //test equality with same value, different proxy
    auto int2Again = env->makeProxy(2);
    POTHOS_TEST_EQUAL(int2.compareTo(int2), 0);
    POTHOS_TEST_EQUAL(int2.compareTo(int2Again), 0);
}

template <typename T>
void testPrimArray(Pothos::ProxyEnvironment::Sptr env, const long div)
{
    //create test vector
    std::vector<T> testVec(17);
    for (size_t i = 0; i < testVec.size(); i++) testVec[i] = T((std::rand()-RAND_MAX/2)/div);

    //convert into proxy
    Pothos::Proxy arrayProxy = env->makeProxy(testVec);

    //check result
    auto resultVec = arrayProxy.convert<std::vector<T>>();
    POTHOS_TEST_EQUALV(testVec, resultVec);
}

POTHOS_TEST_BLOCK("/proxy/java/tests", test_prim_array)
{
    auto env = Pothos::ProxyEnvironment::make("java");
    testPrimArray<char>(env, (RAND_MAX >> 8));
    testPrimArray<short>(env, 1);
    testPrimArray<int>(env, 1);
    testPrimArray<long>(env, 1);
    testPrimArray<long long>(env, 1);
    testPrimArray<float>(env, 1);
    testPrimArray<double>(env, 1);
}

POTHOS_TEST_BLOCK("/proxy/java/tests", test_containers)
{
    auto env = Pothos::ProxyEnvironment::make("java");

    //create test vector
    Pothos::ProxyVector testVec;
    testVec.push_back(env->makeProxy(42));
    testVec.push_back(env->makeProxy("test it"));
    testVec.push_back(env->makeProxy(-21.0));

    //convert into proxy
    auto arrayProxy = env->makeProxy(testVec);
    auto vecObj = arrayProxy.convert<Pothos::ProxyVector>();

    //check result
    POTHOS_TEST_EQUAL(testVec.size(), vecObj.size());
    POTHOS_TEST_EQUAL(testVec[0].convert<int>(), vecObj[0].convert<int>());
    POTHOS_TEST_EQUAL(testVec[1].convert<std::string>(), vecObj[1].convert<std::string>());
    POTHOS_TEST_EQUAL(testVec[2].convert<double>(), vecObj[2].convert<double>());

    //make test set
    Pothos::ProxySet testSet;
    testSet.insert(env->makeProxy("hi"));
    testSet.insert(env->makeProxy(1));

    //convert to proxy and back
    auto proxySet = env->makeProxy(testSet);
    auto resultSet = proxySet.convert<Pothos::ProxySet>();

    //check result
    auto findHiSet = resultSet.find(env->makeProxy("hi"));
    POTHOS_TEST_TRUE(findHiSet != resultSet.end());
    auto find1Set = resultSet.find(env->makeProxy(1));
    POTHOS_TEST_TRUE(find1Set != resultSet.end());

    //make test dictionary
    Pothos::ProxyMap testDict;
    testDict[env->makeProxy("hi")] = env->makeProxy("bye");
    testDict[env->makeProxy(1)] = env->makeProxy(2);

    //convert to proxy and back
    auto proxyDict = env->makeProxy(testDict);
    auto resultDict = proxyDict.convert<Pothos::ProxyMap>();

    //check result
    auto findHi = resultDict.find(env->makeProxy("hi"));
    POTHOS_TEST_TRUE(findHi != resultDict.end());
    POTHOS_TEST_EQUAL(findHi->second.convert<std::string>(), "bye");
    auto find1 = resultDict.find(env->makeProxy(1));
    POTHOS_TEST_TRUE(find1 != resultDict.end());
    POTHOS_TEST_EQUAL(find1->second.convert<int>(), 2);
}

POTHOS_TEST_BLOCK("/proxy/java/tests", test_reflect)
{
    auto env = Pothos::ProxyEnvironment::make("java");
    const std::string str = "this is a test";
    //use the method named "class" to get reflective info:

    //do we get the names expected from the reflect class?
    auto myString = env->makeProxy(str);
    auto strClass = myString.call("class");
    POTHOS_TEST_EQUAL(strClass.call<std::string>("getName"), "java.lang.String");

    auto strBytes = myString.call("getBytes");
    auto bytesClass = strBytes.call("class");
    POTHOS_TEST_EQUAL(bytesClass.call<std::string>("getName"), "[B");

    //check the conversion as well
    auto bytesVec = myString.call<std::vector<char>>("getBytes");
    POTHOS_TEST_EQUALV(bytesVec, str);
}

POTHOS_TEST_BLOCK("/proxy/java/tests", test_primitive)
{
    auto env = Pothos::ProxyEnvironment::make("java");

    auto myBoolean = env->findProxy("java.lang.Boolean").call("new", true);
    POTHOS_TEST_EQUAL(myBoolean.convert<bool>(), true);

    auto myCharacter = env->findProxy("java.lang.Character").call("new", 21);
    POTHOS_TEST_EQUAL(myCharacter.convert<char>(), 21);

    auto myByte = env->findProxy("java.lang.Byte").call("new", -12);
    POTHOS_TEST_EQUAL(myByte.convert<signed char>(), -12);

    auto myShort = env->findProxy("java.lang.Short").call("new", 12345);
    POTHOS_TEST_EQUAL(myShort.convert<short>(), 12345);

    auto myInteger = env->findProxy("java.lang.Integer").call("new", 42);
    POTHOS_TEST_EQUAL(myInteger.convert<int>(), 42);

    auto myLong = env->findProxy("java.lang.Long").call("new", 1ll << 34);
    POTHOS_TEST_EQUAL(myLong.convert<long long>(), 1ll << 34);

    auto myFloat = env->findProxy("java.lang.Float").call("new", -30.0);
    POTHOS_TEST_EQUAL(myFloat.convert<float>(), -30.0);

    auto myDouble = env->findProxy("java.lang.Double").call("new", -20.0);
    POTHOS_TEST_EQUAL(myDouble.convert<double>(), -20.0);
}

POTHOS_TEST_BLOCK("/proxy/java/tests", test_fields)
{
    auto env = Pothos::ProxyEnvironment::make("java");

    auto myInteger = env->findProxy("java.lang.Integer").call("new", 42);
    std::cout << myInteger.call<int>("get:MAX_VALUE") << std::endl;
    //TODO try to set and get a non static field when we find an example object to try it on
}

POTHOS_TEST_BLOCK("/proxy/java/tests", test_serialization)
{
    auto env = Pothos::ProxyEnvironment::make("java");

    //make test dictionary
    Pothos::ProxyMap testDict;
    testDict[env->makeProxy("hi")] = env->makeProxy("bye");
    testDict[env->makeProxy(1)] = env->makeProxy(2);
    auto proxyDict = env->makeProxy(testDict);

    //serialize
    Pothos::Object serializeMe(proxyDict);
    std::stringstream ss;
    serializeMe.serialize(ss);
    std::cout << ss.str() << std::endl;

    //deserialize
    Pothos::Object deserializeMe;
    deserializeMe.deserialize(ss);
    POTHOS_TEST_TRUE(deserializeMe);
    auto resultDict = proxyDict.convert<Pothos::ProxyMap>();

    //check result
    auto findHi = resultDict.find(env->makeProxy("hi"));
    POTHOS_TEST_TRUE(findHi != resultDict.end());
    POTHOS_TEST_EQUAL(findHi->second.convert<std::string>(), "bye");
    auto find1 = resultDict.find(env->makeProxy(1));
    POTHOS_TEST_TRUE(find1 != resultDict.end());
    POTHOS_TEST_EQUAL(find1->second.convert<int>(), 2);
}

POTHOS_TEST_BLOCK("/proxy/java/tests", test_get_inheritance)
{
    auto env = Pothos::ProxyEnvironment::make("java");

    const std::vector<std::string> expectedInheritance =
    {
        "java.io.PipedInputStream",
        "java.io.InputStream",
        "java.lang.Object"
    };
    const std::string& startClassName = expectedInheritance.front();

    auto startClassInstance = env->findProxy(startClassName).call("new");
    auto javaHandle = std::dynamic_pointer_cast<JavaProxyHandle>(startClassInstance.getHandle());
    auto inheritance = javaHandle->getInheritance();

    POTHOS_TEST_EQUALV(expectedInheritance, inheritance);
}

template <typename T>
static void testBufferChunkConversion(Pothos::ProxyEnvironment::Sptr env)
{
    const Pothos::DType dtype(typeid(T));
    std::cout << "Testing " << dtype.toString() << std::endl;

    Pothos::BufferChunk buffIn(dtype, 128);
    for(size_t i = 0; i < buffIn.elements(); ++i)
    {
        buffIn.as<T*>()[i] = T(std::rand() % 100);
    }

    // Convert into a Java direct buffer.
    auto javaBuff = env->makeProxy(buffIn);

    // Convert back and check for equality.
    const auto buffOut = javaBuff.convert<Pothos::BufferChunk>();
    POTHOS_TEST_EQUAL(buffIn.dtype, buffOut.dtype);
    POTHOS_TEST_EQUALA(
        buffIn.as<const T*>(),
        buffOut.as<const T*>(),
        buffOut.elements());
}

POTHOS_TEST_BLOCK("/proxy/java/tests", test_bufferchunk_conversion)
{
    auto env = Pothos::ProxyEnvironment::make("java");

    testBufferChunkConversion<std::int8_t>(env);
    testBufferChunkConversion<std::int16_t>(env);
    testBufferChunkConversion<std::int32_t>(env);
    testBufferChunkConversion<std::int64_t>(env);
    testBufferChunkConversion<float>(env);
    testBufferChunkConversion<double>(env);
}