diff --git a/pkg/gen/filters/filterjava/filters.go b/pkg/gen/filters/filterjava/filters.go index 5168bca9..c70a2c44 100644 --- a/pkg/gen/filters/filterjava/filters.go +++ b/pkg/gen/filters/filterjava/filters.go @@ -14,4 +14,10 @@ func PopulateFuncMap(fm template.FuncMap) { fm["javaAsyncReturn"] = javaAsyncReturn fm["javaTestValue"] = javaTestValue fm["javaElementType"] = javaElementType + fm["javaListReturn"] = javaListReturn + fm["javaListType"] = javaListType + fm["javaListParam"] = javaListParam + fm["javaListParams"] = javaListParams + fm["javaListDefault"] = javaListDefault + fm["javaListAsyncReturn"] = javaListAsyncReturn } diff --git a/pkg/gen/filters/filterjava/java_boxed_type.go b/pkg/gen/filters/filterjava/java_boxed_type.go new file mode 100644 index 00000000..51cc242f --- /dev/null +++ b/pkg/gen/filters/filterjava/java_boxed_type.go @@ -0,0 +1,20 @@ +package filterjava + +// toBoxedType converts a primitive Java type name to its boxed equivalent. +// Non-primitive types are returned unchanged. +func toBoxedType(primitiveType string) string { + switch primitiveType { + case "int": + return "Integer" + case "long": + return "Long" + case "float": + return "Float" + case "double": + return "Double" + case "boolean": + return "Boolean" + default: + return primitiveType + } +} diff --git a/pkg/gen/filters/filterjava/java_list_async_return.go b/pkg/gen/filters/filterjava/java_list_async_return.go new file mode 100644 index 00000000..0a41e044 --- /dev/null +++ b/pkg/gen/filters/filterjava/java_list_async_return.go @@ -0,0 +1,30 @@ +package filterjava + +import ( + "fmt" + + "github.com/apigear-io/cli/pkg/model" +) + +func ToListAsyncReturnString(prefix string, schema *model.Schema) (string, error) { + if schema == nil { + return "xxx", fmt.Errorf("ToListAsyncReturnString schema is nil") + } + if !schema.IsArray { + return ToAsyncReturnString(prefix, schema) + } + inner := schema.InnerSchema() + elementType, err := ToReturnString(prefix, &inner) + if err != nil { + return "xxx", fmt.Errorf("javaListAsyncReturn element type error: %s", err) + } + boxed := toBoxedType(elementType) + return fmt.Sprintf("CompletableFuture>", boxed), nil +} + +func javaListAsyncReturn(prefix string, node *model.TypedNode) (string, error) { + if node == nil { + return "xxx", fmt.Errorf("javaListAsyncReturn node is nil") + } + return ToListAsyncReturnString(prefix, &node.Schema) +} diff --git a/pkg/gen/filters/filterjava/java_list_async_return_test.go b/pkg/gen/filters/filterjava/java_list_async_return_test.go new file mode 100644 index 00000000..334fe752 --- /dev/null +++ b/pkg/gen/filters/filterjava/java_list_async_return_test.go @@ -0,0 +1,115 @@ +package filterjava + +import ( + "testing" + + "github.com/stretchr/testify/assert" +) + +func TestListAsyncReturn(t *testing.T) { + t.Parallel() + syss := loadTestSystems(t) + var propTests = []struct { + mn string + in string + pn string + rt string + }{ + {"test", "Test1", "propVoid", "CompletableFuture"}, + {"test", "Test1", "propBool", "CompletableFuture"}, + {"test", "Test1", "propInt", "CompletableFuture"}, + {"test", "Test1", "propInt32", "CompletableFuture"}, + {"test", "Test1", "propInt64", "CompletableFuture"}, + {"test", "Test1", "propFloat", "CompletableFuture"}, + {"test", "Test1", "propFloat32", "CompletableFuture"}, + {"test", "Test1", "propFloat64", "CompletableFuture"}, + {"test", "Test1", "propString", "CompletableFuture"}, + {"test", "Test1", "propBoolArray", "CompletableFuture>"}, + {"test", "Test1", "propIntArray", "CompletableFuture>"}, + {"test", "Test1", "propInt32Array", "CompletableFuture>"}, + {"test", "Test1", "propInt64Array", "CompletableFuture>"}, + {"test", "Test1", "propFloatArray", "CompletableFuture>"}, + {"test", "Test1", "propFloat32Array", "CompletableFuture>"}, + {"test", "Test1", "propFloat64Array", "CompletableFuture>"}, + {"test", "Test1", "propStringArray", "CompletableFuture>"}, + } + for _, sys := range syss { + for _, tt := range propTests { + t.Run(tt.pn, func(t *testing.T) { + prop := sys.LookupProperty(tt.mn, tt.in, tt.pn) + assert.NotNil(t, prop) + r, err := javaListAsyncReturn("", prop) + assert.NoError(t, err) + assert.Equal(t, tt.rt, r) + }) + } + } +} + +func TestListAsyncOperationReturn(t *testing.T) { + t.Parallel() + syss := loadTestSystems(t) + var propTests = []struct { + mn string + in string + pn string + rt string + }{ + {"test", "Test3", "opVoid", "CompletableFuture"}, + {"test", "Test3", "opBool", "CompletableFuture"}, + {"test", "Test3", "opInt", "CompletableFuture"}, + {"test", "Test3", "opInt32", "CompletableFuture"}, + {"test", "Test3", "opInt64", "CompletableFuture"}, + {"test", "Test3", "opFloat", "CompletableFuture"}, + {"test", "Test3", "opFloat32", "CompletableFuture"}, + {"test", "Test3", "opFloat64", "CompletableFuture"}, + {"test", "Test3", "opString", "CompletableFuture"}, + {"test", "Test3", "opBoolArray", "CompletableFuture>"}, + {"test", "Test3", "opIntArray", "CompletableFuture>"}, + {"test", "Test3", "opInt32Array", "CompletableFuture>"}, + {"test", "Test3", "opInt64Array", "CompletableFuture>"}, + {"test", "Test3", "opFloatArray", "CompletableFuture>"}, + {"test", "Test3", "opFloat32Array", "CompletableFuture>"}, + {"test", "Test3", "opFloat64Array", "CompletableFuture>"}, + {"test", "Test3", "opStringArray", "CompletableFuture>"}, + } + for _, sys := range syss { + for _, tt := range propTests { + t.Run(tt.pn, func(t *testing.T) { + op := sys.LookupOperation(tt.mn, tt.in, tt.pn) + assert.NotNil(t, op) + r, err := javaListAsyncReturn("", op.Return) + assert.NoError(t, err) + assert.Equal(t, tt.rt, r) + }) + } + } +} + +func TestListAsyncReturnExternsYaml(t *testing.T) { + t.Parallel() + table := []struct { + module_name string + interface_name string + operation_name string + result string + }{ + {"test_apigear_next", "Iface1", "func1", "CompletableFuture"}, + {"test_apigear_next", "Iface1", "func3", "CompletableFuture"}, + {"test_apigear_next", "Iface1", "funcList", "CompletableFuture>"}, + {"test_apigear_next", "Iface1", "funcImportedEnum", "CompletableFuture"}, + {"test_apigear_next", "Iface1", "funcImportedStruct", "CompletableFuture"}, + } + syss := loadExternSystemsYAML(t) + for _, sys := range syss { + for _, tt := range table { + t.Run(tt.operation_name, func(t *testing.T) { + op := sys.LookupOperation(tt.module_name, tt.interface_name, tt.operation_name) + assert.NotNil(t, op) + r, err := javaListAsyncReturn("", op.Return) + assert.NoError(t, err) + assert.Equal(t, tt.result, r) + }) + } + } +} diff --git a/pkg/gen/filters/filterjava/java_list_default.go b/pkg/gen/filters/filterjava/java_list_default.go new file mode 100644 index 00000000..91f3a8a7 --- /dev/null +++ b/pkg/gen/filters/filterjava/java_list_default.go @@ -0,0 +1,24 @@ +package filterjava + +import ( + "fmt" + + "github.com/apigear-io/cli/pkg/model" +) + +func ToListDefaultString(schema *model.Schema, prefix string) (string, error) { + if schema == nil { + return "xxx", fmt.Errorf("ToListDefaultString schema is nil") + } + if !schema.IsArray { + return ToDefaultString(schema, prefix) + } + return "new ArrayList<>()", nil +} + +func javaListDefault(prefix string, node *model.TypedNode) (string, error) { + if node == nil { + return "xxx", fmt.Errorf("javaListDefault node is nil") + } + return ToListDefaultString(&node.Schema, prefix) +} diff --git a/pkg/gen/filters/filterjava/java_list_default_test.go b/pkg/gen/filters/filterjava/java_list_default_test.go new file mode 100644 index 00000000..4571f5b2 --- /dev/null +++ b/pkg/gen/filters/filterjava/java_list_default_test.go @@ -0,0 +1,75 @@ +package filterjava + +import ( + "testing" + + "github.com/stretchr/testify/assert" +) + +func TestListDefault(t *testing.T) { + t.Parallel() + syss := loadTestSystems(t) + var propTests = []struct { + mn string + in string + pn string + rt string + }{ + {"test", "Test1", "propBool", "false"}, + {"test", "Test1", "propInt", "0"}, + {"test", "Test1", "propInt32", "0"}, + {"test", "Test1", "propInt64", "0L"}, + {"test", "Test1", "propFloat", "0.0f"}, + {"test", "Test1", "propFloat32", "0.0f"}, + {"test", "Test1", "propFloat64", "0.0"}, + {"test", "Test1", "propString", "new String()"}, + {"test", "Test1", "propBoolArray", "new ArrayList<>()"}, + {"test", "Test1", "propIntArray", "new ArrayList<>()"}, + {"test", "Test1", "propInt32Array", "new ArrayList<>()"}, + {"test", "Test1", "propInt64Array", "new ArrayList<>()"}, + {"test", "Test1", "propFloatArray", "new ArrayList<>()"}, + {"test", "Test1", "propFloat32Array", "new ArrayList<>()"}, + {"test", "Test1", "propFloat64Array", "new ArrayList<>()"}, + {"test", "Test1", "propStringArray", "new ArrayList<>()"}, + } + for _, sys := range syss { + for _, tt := range propTests { + t.Run(tt.pn, func(t *testing.T) { + prop := sys.LookupProperty(tt.mn, tt.in, tt.pn) + assert.NotNil(t, prop) + r, err := javaListDefault("", prop) + assert.NoError(t, err) + assert.Equal(t, tt.rt, r) + }) + } + } +} + +func TestListDefaultSymbols(t *testing.T) { + t.Parallel() + syss := loadTestSystems(t) + var propTests = []struct { + mn string + in string + pn string + rt string + }{ + {"test", "Test2", "propEnum", "Enum1.Default"}, + {"test", "Test2", "propStruct", "new Struct1()"}, + {"test", "Test2", "propInterface", "null"}, + {"test", "Test2", "propEnumArray", "new ArrayList<>()"}, + {"test", "Test2", "propStructArray", "new ArrayList<>()"}, + {"test", "Test2", "propInterfaceArray", "new ArrayList<>()"}, + } + for _, sys := range syss { + for _, tt := range propTests { + t.Run(tt.pn, func(t *testing.T) { + prop := sys.LookupProperty(tt.mn, tt.in, tt.pn) + assert.NotNil(t, prop) + r, err := javaListDefault("", prop) + assert.NoError(t, err) + assert.Equal(t, tt.rt, r) + }) + } + } +} diff --git a/pkg/gen/filters/filterjava/java_list_param.go b/pkg/gen/filters/filterjava/java_list_param.go new file mode 100644 index 00000000..f4ee1e29 --- /dev/null +++ b/pkg/gen/filters/filterjava/java_list_param.go @@ -0,0 +1,30 @@ +package filterjava + +import ( + "fmt" + + "github.com/apigear-io/cli/pkg/model" +) + +func ToListParamString(prefix string, schema *model.Schema, name string) (string, error) { + if schema == nil { + return "xxx", fmt.Errorf("ToListParamString schema is nil") + } + if schema.IsArray { + inner := schema.InnerSchema() + elementType, err := ToReturnString(prefix, &inner) + if err != nil { + return "xxx", fmt.Errorf("javaListParam element type error: %s", err) + } + boxed := toBoxedType(elementType) + return fmt.Sprintf("List<%s> %s", boxed, name), nil + } + return ToParamString(prefix, schema, name) +} + +func javaListParam(prefix string, node *model.TypedNode) (string, error) { + if node == nil { + return "xxx", fmt.Errorf("javaListParam node is nil") + } + return ToListParamString(prefix, &node.Schema, node.Name) +} diff --git a/pkg/gen/filters/filterjava/java_list_param_test.go b/pkg/gen/filters/filterjava/java_list_param_test.go new file mode 100644 index 00000000..7148163e --- /dev/null +++ b/pkg/gen/filters/filterjava/java_list_param_test.go @@ -0,0 +1,75 @@ +package filterjava + +import ( + "testing" + + "github.com/stretchr/testify/assert" +) + +func TestListParam(t *testing.T) { + t.Parallel() + syss := loadTestSystems(t) + var propTests = []struct { + mn string + in string + pn string + rt string + }{ + {"test", "Test1", "propBool", "boolean propBool"}, + {"test", "Test1", "propInt", "int propInt"}, + {"test", "Test1", "propInt32", "int propInt32"}, + {"test", "Test1", "propInt64", "long propInt64"}, + {"test", "Test1", "propFloat", "float propFloat"}, + {"test", "Test1", "propFloat32", "float propFloat32"}, + {"test", "Test1", "propFloat64", "double propFloat64"}, + {"test", "Test1", "propString", "String propString"}, + {"test", "Test1", "propBoolArray", "List propBoolArray"}, + {"test", "Test1", "propIntArray", "List propIntArray"}, + {"test", "Test1", "propInt32Array", "List propInt32Array"}, + {"test", "Test1", "propInt64Array", "List propInt64Array"}, + {"test", "Test1", "propFloatArray", "List propFloatArray"}, + {"test", "Test1", "propFloat32Array", "List propFloat32Array"}, + {"test", "Test1", "propFloat64Array", "List propFloat64Array"}, + {"test", "Test1", "propStringArray", "List propStringArray"}, + } + for _, sys := range syss { + for _, tt := range propTests { + t.Run(tt.pn, func(t *testing.T) { + prop := sys.LookupProperty(tt.mn, tt.in, tt.pn) + assert.NotNil(t, prop) + r, err := javaListParam("", prop) + assert.NoError(t, err) + assert.Equal(t, tt.rt, r) + }) + } + } +} + +func TestListParamSymbols(t *testing.T) { + t.Parallel() + syss := loadTestSystems(t) + var propTests = []struct { + mn string + in string + pn string + rt string + }{ + {"test", "Test2", "propEnum", "Enum1 propEnum"}, + {"test", "Test2", "propStruct", "Struct1 propStruct"}, + {"test", "Test2", "propInterface", "IInterface1 propInterface"}, + {"test", "Test2", "propEnumArray", "List propEnumArray"}, + {"test", "Test2", "propStructArray", "List propStructArray"}, + {"test", "Test2", "propInterfaceArray", "List propInterfaceArray"}, + } + for _, sys := range syss { + for _, tt := range propTests { + t.Run(tt.pn, func(t *testing.T) { + prop := sys.LookupProperty(tt.mn, tt.in, tt.pn) + assert.NotNil(t, prop) + r, err := javaListParam("", prop) + assert.NoError(t, err) + assert.Equal(t, tt.rt, r) + }) + } + } +} diff --git a/pkg/gen/filters/filterjava/java_list_params.go b/pkg/gen/filters/filterjava/java_list_params.go new file mode 100644 index 00000000..e5335395 --- /dev/null +++ b/pkg/gen/filters/filterjava/java_list_params.go @@ -0,0 +1,23 @@ +package filterjava + +import ( + "fmt" + "strings" + + "github.com/apigear-io/cli/pkg/model" +) + +func javaListParams(prefix string, nodes []*model.TypedNode) (string, error) { + if nodes == nil { + return "xxx", fmt.Errorf("javaListParams called with nil nodes") + } + var params []string + for _, p := range nodes { + r, err := ToListParamString(prefix, &p.Schema, p.Name) + if err != nil { + return "xxx", err + } + params = append(params, r) + } + return strings.Join(params, ", "), nil +} diff --git a/pkg/gen/filters/filterjava/java_list_params_test.go b/pkg/gen/filters/filterjava/java_list_params_test.go new file mode 100644 index 00000000..85e5cdbd --- /dev/null +++ b/pkg/gen/filters/filterjava/java_list_params_test.go @@ -0,0 +1,49 @@ +package filterjava + +import ( + "testing" + + "github.com/stretchr/testify/assert" +) + +func TestListParams(t *testing.T) { + t.Parallel() + table := []struct { + mn string + in string + pn string + rt string + }{ + {"test", "Test3", "opBool", "boolean param1"}, + {"test", "Test3", "opInt", "int param1"}, + {"test", "Test3", "opInt32", "int param1"}, + {"test", "Test3", "opInt64", "long param1"}, + {"test", "Test3", "opFloat", "float param1"}, + {"test", "Test3", "opFloat32", "float param1"}, + {"test", "Test3", "opFloat64", "double param1"}, + {"test", "Test3", "opString", "String param1"}, + {"test", "Test3", "opBoolArray", "List param1"}, + {"test", "Test3", "opIntArray", "List param1"}, + {"test", "Test3", "opInt32Array", "List param1"}, + {"test", "Test3", "opInt64Array", "List param1"}, + {"test", "Test3", "opFloatArray", "List param1"}, + {"test", "Test3", "opFloat32Array", "List param1"}, + {"test", "Test3", "opFloat64Array", "List param1"}, + {"test", "Test3", "opStringArray", "List param1"}, + {"test", "Test3", "op_Bool", "boolean param_Bool"}, + {"test", "Test3", "op_bool", "boolean param_bool"}, + {"test", "Test3", "op_1", "boolean param_1"}, + } + syss := loadTestSystems(t) + for _, sys := range syss { + for _, tt := range table { + t.Run(tt.pn, func(t *testing.T) { + m := sys.LookupOperation(tt.mn, tt.in, tt.pn) + assert.NotNil(t, m) + r, err := javaListParams("", m.Params) + assert.NoError(t, err) + assert.Equal(t, tt.rt, r) + }) + } + } +} diff --git a/pkg/gen/filters/filterjava/java_list_return.go b/pkg/gen/filters/filterjava/java_list_return.go new file mode 100644 index 00000000..afcbc4cb --- /dev/null +++ b/pkg/gen/filters/filterjava/java_list_return.go @@ -0,0 +1,30 @@ +package filterjava + +import ( + "fmt" + + "github.com/apigear-io/cli/pkg/model" +) + +func ToListReturnString(prefix string, schema *model.Schema) (string, error) { + if schema == nil { + return "xxx", fmt.Errorf("ToListReturnString schema is nil") + } + if !schema.IsArray { + return ToReturnString(prefix, schema) + } + inner := schema.InnerSchema() + elementType, err := ToReturnString(prefix, &inner) + if err != nil { + return "xxx", fmt.Errorf("javaListReturn element type error: %s", err) + } + boxed := toBoxedType(elementType) + return fmt.Sprintf("List<%s>", boxed), nil +} + +func javaListReturn(prefix string, node *model.TypedNode) (string, error) { + if node == nil { + return "xxx", fmt.Errorf("javaListReturn node is nil") + } + return ToListReturnString(prefix, &node.Schema) +} diff --git a/pkg/gen/filters/filterjava/java_list_return_test.go b/pkg/gen/filters/filterjava/java_list_return_test.go new file mode 100644 index 00000000..d235a826 --- /dev/null +++ b/pkg/gen/filters/filterjava/java_list_return_test.go @@ -0,0 +1,144 @@ +package filterjava + +import ( + "testing" + + "github.com/stretchr/testify/assert" +) + +func TestListReturn(t *testing.T) { + t.Parallel() + syss := loadTestSystems(t) + var propTests = []struct { + mn string + in string + pn string + rt string + }{ + {"test", "Test1", "propVoid", "void"}, + {"test", "Test1", "propBool", "boolean"}, + {"test", "Test1", "propInt", "int"}, + {"test", "Test1", "propInt32", "int"}, + {"test", "Test1", "propInt64", "long"}, + {"test", "Test1", "propFloat", "float"}, + {"test", "Test1", "propFloat32", "float"}, + {"test", "Test1", "propFloat64", "double"}, + {"test", "Test1", "propString", "String"}, + {"test", "Test1", "propBoolArray", "List"}, + {"test", "Test1", "propIntArray", "List"}, + {"test", "Test1", "propInt32Array", "List"}, + {"test", "Test1", "propInt64Array", "List"}, + {"test", "Test1", "propFloatArray", "List"}, + {"test", "Test1", "propFloat32Array", "List"}, + {"test", "Test1", "propFloat64Array", "List"}, + {"test", "Test1", "propStringArray", "List"}, + } + for _, sys := range syss { + for _, tt := range propTests { + t.Run(tt.pn, func(t *testing.T) { + prop := sys.LookupProperty(tt.mn, tt.in, tt.pn) + assert.NotNil(t, prop) + r, err := javaListReturn("", prop) + assert.NoError(t, err) + assert.Equal(t, tt.rt, r) + }) + } + } +} + +func TestListOperationReturn(t *testing.T) { + t.Parallel() + syss := loadTestSystems(t) + var propTests = []struct { + mn string + in string + pn string + rt string + }{ + {"test", "Test3", "opVoid", "void"}, + {"test", "Test3", "opBool", "boolean"}, + {"test", "Test3", "opInt", "int"}, + {"test", "Test3", "opInt32", "int"}, + {"test", "Test3", "opInt64", "long"}, + {"test", "Test3", "opFloat", "float"}, + {"test", "Test3", "opFloat32", "float"}, + {"test", "Test3", "opFloat64", "double"}, + {"test", "Test3", "opString", "String"}, + {"test", "Test3", "opBoolArray", "List"}, + {"test", "Test3", "opIntArray", "List"}, + {"test", "Test3", "opInt32Array", "List"}, + {"test", "Test3", "opInt64Array", "List"}, + {"test", "Test3", "opFloatArray", "List"}, + {"test", "Test3", "opFloat32Array", "List"}, + {"test", "Test3", "opFloat64Array", "List"}, + {"test", "Test3", "opStringArray", "List"}, + } + for _, sys := range syss { + for _, tt := range propTests { + t.Run(tt.pn, func(t *testing.T) { + op := sys.LookupOperation(tt.mn, tt.in, tt.pn) + assert.NotNil(t, op) + r, err := javaListReturn("", op.Return) + assert.NoError(t, err) + assert.Equal(t, tt.rt, r) + }) + } + } +} + +func TestListReturnSymbols(t *testing.T) { + t.Parallel() + syss := loadTestSystems(t) + var propTests = []struct { + mn string + in string + pn string + rt string + }{ + {"test", "Test2", "propEnum", "Enum1"}, + {"test", "Test2", "propStruct", "Struct1"}, + {"test", "Test2", "propInterface", "IInterface1"}, + {"test", "Test2", "propEnumArray", "List"}, + {"test", "Test2", "propStructArray", "List"}, + {"test", "Test2", "propInterfaceArray", "List"}, + } + for _, sys := range syss { + for _, tt := range propTests { + t.Run(tt.pn, func(t *testing.T) { + prop := sys.LookupProperty(tt.mn, tt.in, tt.pn) + assert.NotNil(t, prop) + r, err := javaListReturn("", prop) + assert.NoError(t, err) + assert.Equal(t, tt.rt, r) + }) + } + } +} + +func TestListReturnExternsYaml(t *testing.T) { + t.Parallel() + table := []struct { + module_name string + interface_name string + operation_name string + result string + }{ + {"test_apigear_next", "Iface1", "func1", "XType1"}, + {"test_apigear_next", "Iface1", "func3", "demo.x.XType3A"}, + {"test_apigear_next", "Iface1", "funcList", "List"}, + {"test_apigear_next", "Iface1", "funcImportedEnum", "test.test_api.Enum1"}, + {"test_apigear_next", "Iface1", "funcImportedStruct", "test.test_api.Struct1"}, + } + syss := loadExternSystemsYAML(t) + for _, sys := range syss { + for _, tt := range table { + t.Run(tt.operation_name, func(t *testing.T) { + op := sys.LookupOperation(tt.module_name, tt.interface_name, tt.operation_name) + assert.NotNil(t, op) + r, err := javaListReturn("", op.Return) + assert.NoError(t, err) + assert.Equal(t, tt.result, r) + }) + } + } +} diff --git a/pkg/gen/filters/filterjava/java_list_type.go b/pkg/gen/filters/filterjava/java_list_type.go new file mode 100644 index 00000000..0552f2c1 --- /dev/null +++ b/pkg/gen/filters/filterjava/java_list_type.go @@ -0,0 +1,3 @@ +package filterjava + +var javaListType = javaListReturn