swig/Examples/test-suite/java/cpp11_std_unique_ptr_runme.java
William S Fulton 6b361bf050 Add Java support for std::unique<T> for input parameters.
This works by transferring ownership of the underlying C++ memory
from the target language proxy class to an instance of the unique_ptr
which is passed to the wrapped function via std::move.

The proxy class has a new swigRelease() method which sets the
underlying C++ pointer for the proxy class to null, so working
in much the same way as std::unique_ptr::release(). Any attempt at
using the proxy class will be the same as if the delete() function
has been called on the proxy class. That is, using a C++ null pointer,
when a non-null pointer is usually expected.

This commit relies on the previous commit that uses std::move
on the temporary variable used for the wrapped function's input parameter
as std::unique_ptr is not copyable, it has move-only semantics.
2022-07-17 15:15:24 +01:00

102 lines
3.4 KiB
Java

import cpp11_std_unique_ptr.*;
public class cpp11_std_unique_ptr_runme {
static {
try {
System.loadLibrary("cpp11_std_unique_ptr");
} catch (UnsatisfiedLinkError e) {
System.err.println("Native code library failed to load. See the chapter on Dynamic Linking Problems in the SWIG Java documentation for help.\n" + e);
System.exit(1);
}
}
private static void WaitForGC()
{
System.gc();
System.runFinalization();
try {
java.lang.Thread.sleep(10);
} catch (java.lang.InterruptedException e) {
}
}
private static void checkCount(int expected_count) {
int actual_count = Klass.getTotal_count();
if (actual_count != expected_count)
throw new RuntimeException("Counts incorrect, expected:" + expected_count + " actual:" + actual_count);
}
public static void main(String argv[]) throws Throwable
{
// unique_ptr as input
{
Klass kin = new Klass("KlassInput");
checkCount(1);
String s = cpp11_std_unique_ptr.takeKlassUniquePtr(kin);
checkCount(0);
if (!s.equals("KlassInput"))
throw new RuntimeException("Incorrect string: " + s);
if (!cpp11_std_unique_ptr.is_nullptr(kin))
throw new RuntimeException("is_nullptr failed");
kin.delete(); // Should not fail, even though already deleted
checkCount(0);
}
{
KlassInheritance kini = new KlassInheritance("KlassInheritanceInput");
checkCount(1);
String s = cpp11_std_unique_ptr.takeKlassUniquePtr(kini);
checkCount(0);
if (!s.equals("KlassInheritanceInput"))
throw new RuntimeException("Incorrect string: " + s);
if (!cpp11_std_unique_ptr.is_nullptr(kini))
throw new RuntimeException("is_nullptr failed");
kini.delete(); // Should not fail, even though already deleted
checkCount(0);
}
// unique_ptr as output
Klass k1 = cpp11_std_unique_ptr.makeKlassUniquePtr("first");
if (!k1.getLabel().equals("first"))
throw new RuntimeException("wrong object label");
Klass k2 = cpp11_std_unique_ptr.makeKlassUniquePtr("second");
if (Klass.getTotal_count() != 2)
throw new RuntimeException("number of objects should be 2");
k1 = null;
{
int countdown = 500;
int expectedCount = 1;
while (true) {
WaitForGC();
if (--countdown == 0)
break;
if (Klass.getTotal_count() == expectedCount)
break;
}
int actualCount = Klass.getTotal_count();
if (actualCount != expectedCount)
System.err.println("GC failed to run (cpp11_std_unique_ptr 1). Expected count: " + expectedCount + " Actual count: " + actualCount); // Finalizers are not guaranteed to be run and sometimes they just don't
}
if (!k2.getLabel().equals("second"))
throw new RuntimeException("wrong object label");
k2 = null;
{
int countdown = 500;
int expectedCount = 0;
while (true) {
WaitForGC();
if (--countdown == 0)
break;
if (Klass.getTotal_count() == expectedCount)
break;
};
int actualCount = Klass.getTotal_count();
if (actualCount != expectedCount)
System.err.println("GC failed to run (cpp11_std_unique_ptr 2). Expected count: " + expectedCount + " Actual count: " + actualCount); // Finalizers are not guaranteed to be run and sometimes they just don't
}
}
}