Fixed #1304: Migrate tests from the Scala to the plain Java. Part 1

modules/swagger-codegen/src/test/java/io/swagger/codegen/ClientAuthInputTest.java

@@ -0,0 +1,41 @@
+package io.swagger.codegen;
+
+import io.swagger.models.auth.AuthorizationValue;
+
+import org.testng.Assert;
+import org.testng.annotations.Test;
+
+import java.util.List;
+
+public class ClientAuthInputTest {
+
+    @Test(description = "read a file upload param from a 2.0 spec")
+    public void clientAuthInputTest() {
+        final ClientOptInput input = new ClientOptInput();
+
+        final String header = "api_key:special-key,api_key:hello,X-AUTHORIZATION:0e6c11d79a,Authorization:Basic 1jz0";
+        input.setAuth(header);
+        final List<AuthorizationValue> authValues = input.getAuthorizationValues();
+        Assert.assertEquals(authValues.size(), 4);
+
+        final AuthorizationValue a1 = authValues.get(0);
+        Assert.assertEquals(a1.getKeyName(), "api_key");
+        Assert.assertEquals(a1.getValue(), "special-key");
+        Assert.assertEquals(a1.getType(), "header");
+
+        final AuthorizationValue a2 = authValues.get(1);
+        Assert.assertEquals(a2.getKeyName(), "api_key");
+        Assert.assertEquals(a2.getValue(), "hello");
+        Assert.assertEquals(a2.getType(), "header");
+
+        final AuthorizationValue a3 = authValues.get(2);
+        Assert.assertEquals(a3.getKeyName(), "X-AUTHORIZATION");
+        Assert.assertEquals(a3.getValue(), "0e6c11d79a");
+        Assert.assertEquals(a3.getType(), "header");
+
+        final AuthorizationValue a4 = authValues.get(3);
+        Assert.assertEquals(a4.getKeyName(), "Authorization");
+        Assert.assertEquals(a4.getValue(), "Basic 1jz0");
+        Assert.assertEquals(a4.getType(), "header");
+    }
+}

modules/swagger-codegen/src/test/java/io/swagger/codegen/SwaggerMigratorTest.java

@@ -0,0 +1,15 @@
+package io.swagger.codegen;
+
+import io.swagger.models.Swagger;
+import io.swagger.parser.SwaggerParser;
+
+import org.testng.annotations.Test;
+
+public class SwaggerMigratorTest {
+
+    @Test(description = "read a 1.2 spec")
+    public void swaggerMigratorTest() {
+        final SwaggerParser loader = new SwaggerParser();
+        final Swagger swagger = loader.read("src/test/resources/1_2/petstore-1.2/api-docs");
+    }
+}

modules/swagger-codegen/src/test/java/io/swagger/codegen/java/JavaInheritanceTest.java

@@ -0,0 +1,31 @@
+package io.swagger.codegen.java;
+
+import io.swagger.codegen.CodegenModel;
+import io.swagger.codegen.DefaultCodegen;
+import io.swagger.codegen.languages.JavaClientCodegen;
+import io.swagger.models.ComposedModel;
+import io.swagger.models.Model;
+import io.swagger.models.ModelImpl;
+import io.swagger.models.RefModel;
+import io.swagger.models.properties.StringProperty;
+
+import com.google.common.collect.Sets;
+import org.testng.Assert;
+import org.testng.annotations.Test;
+
+public class JavaInheritanceTest {
+
+    @Test(description = "convert a composed model")
+    public void javaInheritanceTest() {
+        final Model model = new ComposedModel().parent(new RefModel("Base"))
+                .child(new ModelImpl().additionalProperties(new StringProperty()));
+
+        final DefaultCodegen codegen = new JavaClientCodegen();
+        final CodegenModel cm = codegen.fromModel("sample", model);
+
+        Assert.assertEquals(cm.name, "sample");
+        Assert.assertEquals(cm.classname, "Sample");
+        Assert.assertEquals(cm.parent, "Base");
+        Assert.assertEquals(cm.imports, Sets.newHashSet("Base"));
+    }
+}

modules/swagger-codegen/src/test/java/io/swagger/codegen/java/JavaModelEnumTest.java

@@ -0,0 +1,96 @@
+package io.swagger.codegen.java;
+
+import io.swagger.codegen.CodegenModel;
+import io.swagger.codegen.CodegenProperty;
+import io.swagger.codegen.DefaultCodegen;
+import io.swagger.codegen.languages.JavaClientCodegen;
+import io.swagger.models.ComposedModel;
+import io.swagger.models.Model;
+import io.swagger.models.ModelImpl;
+import io.swagger.models.RefModel;
+import io.swagger.models.properties.Property;
+import io.swagger.models.properties.StringProperty;
+
+import org.testng.Assert;
+import org.testng.annotations.Test;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+
+public class JavaModelEnumTest {
+
+    @Test(description = "convert a java model with an enum")
+    public void converterTest() {
+        final StringProperty enumProperty = new StringProperty();
+        enumProperty.setEnum(Arrays.asList("VALUE1", "VALUE2", "VALUE3"));
+        final ModelImpl model = new ModelImpl().property("name", enumProperty);
+
+        final DefaultCodegen codegen = new JavaClientCodegen();
+        final CodegenModel cm = codegen.fromModel("sample", model);
+
+        Assert.assertEquals(cm.vars.size(), 1);
+
+        final CodegenProperty enumVar = cm.vars.get(0);
+        Assert.assertEquals(enumVar.baseName, "name");
+        Assert.assertEquals(enumVar.datatype, "String");
+        Assert.assertEquals(enumVar.datatypeWithEnum, "NameEnum");
+        Assert.assertEquals(enumVar.name, "name");
+        Assert.assertEquals(enumVar.defaultValue, "null");
+        Assert.assertEquals(enumVar.baseType, "String");
+        Assert.assertTrue(enumVar.isEnum);
+    }
+
+    @Test(description = "not override identical parent enums")
+    public void overrideEnumTest() {
+        final StringProperty identicalEnumProperty = new StringProperty();
+        identicalEnumProperty.setEnum(Arrays.asList("VALUE1", "VALUE2", "VALUE3"));
+
+        final StringProperty subEnumProperty = new StringProperty();
+        subEnumProperty.setEnum(Arrays.asList("SUB1", "SUB2", "SUB3"));
+
+        // Add one enum property to the parent
+        final Map<String, Property> parentProperties = new HashMap<String, Property>();
+        parentProperties.put("sharedThing", identicalEnumProperty);
+
+        // Add TWO enums to the subType model; one of which is identical to the one in parent class
+        final Map<String, Property> subProperties = new HashMap<String, Property>();
+        subProperties.put("sharedThing", identicalEnumProperty);
+        subProperties.put("unsharedThing", identicalEnumProperty);
+
+        final ModelImpl parentModel = new ModelImpl();
+        parentModel.setProperties(parentProperties);
+        parentModel.name("parentModel");
+
+        final ModelImpl subModel = new ModelImpl();
+        subModel.setProperties(subProperties);
+        subModel.name("subModel");
+
+        final ComposedModel model = new ComposedModel()
+                .parent(new RefModel(parentModel.getName()))
+                .child(subModel)
+                .interfaces(new ArrayList<RefModel>());
+
+        final DefaultCodegen codegen = new JavaClientCodegen();
+        final Map<String, Model> allModels = new HashMap<String, Model>();
+        allModels.put(codegen.toModelName(parentModel.getName()), parentModel);
+        allModels.put(codegen.toModelName(subModel.getName()), subModel);
+
+        final CodegenModel cm = codegen.fromModel("sample", model, allModels);
+
+        Assert.assertEquals(cm.name, "sample");
+        Assert.assertEquals(cm.classname, "Sample");
+        Assert.assertEquals(cm.parent, "ParentModel");
+        Assert.assertEquals(cm.imports, Collections.singletonList("ParentModel"));
+
+        // Assert that only the unshared/uninherited enum remains
+        Assert.assertEquals(cm.vars.size(), 1);
+        final CodegenProperty enumVar = cm.vars.get(0);
+        Assert.assertEquals(enumVar.baseName, "unsharedThing");
+        Assert.assertEquals(enumVar.datatype, "String");
+        Assert.assertEquals(enumVar.datatypeWithEnum, "UnsharedThingEnum");
+        Assert.assertTrue(enumVar.isEnum);
+    }
+}

modules/swagger-codegen/src/test/java/io/swagger/codegen/java/JavaModelTest.java

@@ -0,0 +1,456 @@
+package io.swagger.codegen.java;
+
+import io.swagger.codegen.CodegenModel;
+import io.swagger.codegen.CodegenParameter;
+import io.swagger.codegen.CodegenProperty;
+import io.swagger.codegen.DefaultCodegen;
+import io.swagger.codegen.languages.JavaClientCodegen;
+import io.swagger.models.ArrayModel;
+import io.swagger.models.Model;
+import io.swagger.models.ModelImpl;
+import io.swagger.models.parameters.QueryParameter;
+import io.swagger.models.properties.ArrayProperty;
+import io.swagger.models.properties.ByteArrayProperty;
+import io.swagger.models.properties.DateTimeProperty;
+import io.swagger.models.properties.IntegerProperty;
+import io.swagger.models.properties.LongProperty;
+import io.swagger.models.properties.MapProperty;
+import io.swagger.models.properties.RefProperty;
+import io.swagger.models.properties.StringProperty;
+
+import com.google.common.collect.Sets;
+import org.testng.Assert;
+import org.testng.annotations.Test;
+
+import java.util.List;
+
+public class JavaModelTest {
+
+    @Test(description = "convert a simple java model")
+    public void simpleModelTest() {
+        final Model model = new ModelImpl()
+                .description("a sample model")
+                .property("id", new LongProperty())
+                .property("name", new StringProperty())
+                .property("createdAt", new DateTimeProperty())
+                .required("id")
+                .required("name");
+        final DefaultCodegen codegen = new JavaClientCodegen();
+        final CodegenModel cm = codegen.fromModel("sample", model);
+
+        Assert.assertEquals(cm.name, "sample");
+        Assert.assertEquals(cm.classname, "Sample");
+        Assert.assertEquals(cm.description, "a sample model");
+        Assert.assertEquals(cm.vars.size(), 3);
+
+        final List<CodegenProperty> vars = cm.vars;
+
+        final CodegenProperty property1 = vars.get(0);
+        Assert.assertEquals(property1.baseName, "id");
+        Assert.assertEquals(property1.getter, "getId");
+        Assert.assertEquals(property1.setter, "setId");
+        Assert.assertEquals(property1.datatype, "Long");
+        Assert.assertEquals(property1.name, "id");
+        Assert.assertEquals(property1.defaultValue, "null");
+        Assert.assertEquals(property1.baseType, "Long");
+        Assert.assertTrue(property1.hasMore);
+        Assert.assertTrue(property1.required);
+        Assert.assertTrue(property1.isNotContainer);
+
+        final CodegenProperty property2 = vars.get(1);
+        Assert.assertEquals(property2.baseName, "name");
+        Assert.assertEquals(property2.getter, "getName");
+        Assert.assertEquals(property2.setter, "setName");
+        Assert.assertEquals(property2.datatype, "String");
+        Assert.assertEquals(property2.name, "name");
+        Assert.assertEquals(property2.defaultValue, "null");
+        Assert.assertEquals(property2.baseType, "String");
+        Assert.assertTrue(property2.hasMore);
+        Assert.assertTrue(property2.required);
+        Assert.assertTrue(property2.isNotContainer);
+
+        final CodegenProperty property3 = vars.get(2);
+        Assert.assertEquals(property3.baseName, "createdAt");
+        Assert.assertEquals(property3.getter, "getCreatedAt");
+        Assert.assertEquals(property3.setter, "setCreatedAt");
+        Assert.assertEquals(property3.datatype, "Date");
+        Assert.assertEquals(property3.name, "createdAt");
+        Assert.assertEquals(property3.defaultValue, "null");
+        Assert.assertEquals(property3.baseType, "Date");
+        Assert.assertNull(property3.hasMore);
+        Assert.assertNull(property3.required);
+        Assert.assertTrue(property3.isNotContainer);
+    }
+
+    @Test(description = "convert a model with list property")
+    public void listPropertyTest() {
+        final Model model = new ModelImpl()
+                .description("a sample model")
+                .property("id", new LongProperty())
+                .property("urls", new ArrayProperty()
+                        .items(new StringProperty()))
+                .required("id");
+        final DefaultCodegen codegen = new JavaClientCodegen();
+        final CodegenModel cm = codegen.fromModel("sample", model);
+
+        Assert.assertEquals(cm.name, "sample");
+        Assert.assertEquals(cm.classname, "Sample");
+        Assert.assertEquals(cm.description, "a sample model");
+        Assert.assertEquals(cm.vars.size(), 2);
+
+        final CodegenProperty property = cm.vars.get(1);
+        Assert.assertEquals(property.baseName, "urls");
+        Assert.assertEquals(property.getter, "getUrls");
+        Assert.assertEquals(property.setter, "setUrls");
+        Assert.assertEquals(property.datatype, "List<String>");
+        Assert.assertEquals(property.name, "urls");
+        Assert.assertEquals(property.defaultValue, "new ArrayList<String>()");
+        Assert.assertEquals(property.baseType, "List");
+        Assert.assertEquals(property.containerType, "array");
+        Assert.assertNull(property.required);
+        Assert.assertTrue(property.isContainer);
+    }
+
+    @Test(description = "convert a model with a map property")
+    public void mapPropertyTest() {
+        final Model model = new ModelImpl()
+                .description("a sample model")
+                .property("translations", new MapProperty()
+                        .additionalProperties(new StringProperty()))
+                .required("id");
+        final DefaultCodegen codegen = new JavaClientCodegen();
+        final CodegenModel cm = codegen.fromModel("sample", model);
+
+        Assert.assertEquals(cm.name, "sample");
+        Assert.assertEquals(cm.classname, "Sample");
+        Assert.assertEquals(cm.description, "a sample model");
+        Assert.assertEquals(cm.vars.size(), 1);
+
+        final CodegenProperty property = cm.vars.get(0);
+        Assert.assertEquals(property.baseName, "translations");
+        Assert.assertEquals(property.getter, "getTranslations");
+        Assert.assertEquals(property.setter, "setTranslations");
+        Assert.assertEquals(property.datatype, "Map<String, String>");
+        Assert.assertEquals(property.name, "translations");
+        Assert.assertEquals(property.defaultValue, "new HashMap<String, String>()");
+        Assert.assertEquals(property.baseType, "Map");
+        Assert.assertEquals(property.containerType, "map");
+        Assert.assertNull(property.required);
+        Assert.assertTrue(property.isContainer);
+    }
+
+    @Test(description = "convert a model with a map with complex list property")
+    public void mapWithListPropertyTest() {
+        final Model model = new ModelImpl()
+                .description("a sample model")
+                .property("translations",
+                        new MapProperty().additionalProperties(new ArrayProperty().items(new RefProperty("Pet"))))
+                .required("id");
+        final DefaultCodegen codegen = new JavaClientCodegen();
+        final CodegenModel cm = codegen.fromModel("sample", model);
+
+        Assert.assertEquals(cm.name, "sample");
+        Assert.assertEquals(cm.classname, "Sample");
+        Assert.assertEquals(cm.description, "a sample model");
+        Assert.assertEquals(cm.vars.size(), 1);
+
+        final CodegenProperty property = cm.vars.get(0);
+        Assert.assertEquals(property.baseName, "translations");
+        Assert.assertEquals(property.getter, "getTranslations");
+        Assert.assertEquals(property.setter, "setTranslations");
+        Assert.assertEquals(property.datatype, "Map<String, List<Pet>>");
+        Assert.assertEquals(property.name, "translations");
+        Assert.assertEquals(property.defaultValue, "new HashMap<String, List<Pet>>()");
+        Assert.assertEquals(property.baseType, "Map");
+        Assert.assertEquals(property.containerType, "map");
+        Assert.assertNull(property.required);
+        Assert.assertTrue(property.isContainer);
+    }
+
+    @Test(description = "convert a model with a 2D list property")
+    public void list2DPropertyTest() {
+        final Model model = new ModelImpl().name("sample").property("list2D", new ArrayProperty().items(
+                new ArrayProperty().items(new RefProperty("Pet"))));
+        final DefaultCodegen codegen = new JavaClientCodegen();
+        final CodegenModel cm = codegen.fromModel("sample", model);
+
+        Assert.assertEquals(cm.vars.size(), 1);
+
+        final CodegenProperty property = cm.vars.get(0);
+        Assert.assertEquals(property.baseName, "list2D");
+        Assert.assertEquals(property.getter, "getList2D");
+        Assert.assertEquals(property.setter, "setList2D");
+        Assert.assertEquals(property.datatype, "List<List<Pet>>");
+        Assert.assertEquals(property.name, "list2D");
+        Assert.assertEquals(property.defaultValue, "new ArrayList<List<Pet>>()");
+        Assert.assertEquals(property.baseType, "List");
+        Assert.assertEquals(property.containerType, "array");
+        Assert.assertNull(property.required);
+        Assert.assertTrue(property.isContainer);
+    }
+
+    @Test(description = "convert a model with complex properties")
+    public void complexPropertiesTest() {
+        final Model model = new ModelImpl().description("a sample model")
+                .property("children", new RefProperty("#/definitions/Children"));
+        final DefaultCodegen codegen = new JavaClientCodegen();
+        final CodegenModel cm = codegen.fromModel("sample", model);
+
+        Assert.assertEquals(cm.name, "sample");
+        Assert.assertEquals(cm.classname, "Sample");
+        Assert.assertEquals(cm.description, "a sample model");
+        Assert.assertEquals(cm.vars.size(), 1);
+
+        final CodegenProperty property = cm.vars.get(0);
+        Assert.assertEquals(property.baseName, "children");
+        Assert.assertEquals(property.getter, "getChildren");
+        Assert.assertEquals(property.setter, "setChildren");
+        Assert.assertEquals(property.datatype, "Children");
+        Assert.assertEquals(property.name, "children");
+        Assert.assertEquals(property.defaultValue, "null");
+        Assert.assertEquals(property.baseType, "Children");
+        Assert.assertNull(property.required);
+        Assert.assertTrue(property.isNotContainer);
+    }
+
+    @Test(description = "convert a model with complex list property")
+    public void complexListPropertyTest() {
+        final Model model = new ModelImpl()
+                .description("a sample model")
+                .property("children", new ArrayProperty().items(new RefProperty("#/definitions/Children")));
+        final DefaultCodegen codegen = new JavaClientCodegen();
+        final CodegenModel cm = codegen.fromModel("sample", model);
+
+        Assert.assertEquals(cm.name, "sample");
+        Assert.assertEquals(cm.classname, "Sample");
+        Assert.assertEquals(cm.description, "a sample model");
+        Assert.assertEquals(cm.vars.size(), 1);
+
+        final CodegenProperty property = cm.vars.get(0);
+        Assert.assertEquals(property.baseName, "children");
+        Assert.assertEquals(property.complexType, "Children");
+        Assert.assertEquals(property.getter, "getChildren");
+        Assert.assertEquals(property.setter, "setChildren");
+        Assert.assertEquals(property.datatype, "List<Children>");
+        Assert.assertEquals(property.name, "children");
+        Assert.assertEquals(property.defaultValue, "new ArrayList<Children>()");
+        Assert.assertEquals(property.baseType, "List");
+        Assert.assertEquals(property.containerType, "array");
+        Assert.assertNull(property.required);
+        Assert.assertTrue(property.isContainer);
+    }
+
+    @Test(description = "convert a model with complex map property")
+    public void complexMapPropertyTest() {
+        final Model model = new ModelImpl()
+                .description("a sample model")
+                .property("children", new MapProperty().additionalProperties(new RefProperty("#/definitions/Children")));
+        final DefaultCodegen codegen = new JavaClientCodegen();
+        final CodegenModel cm = codegen.fromModel("sample", model);
+
+        Assert.assertEquals(cm.name, "sample");
+        Assert.assertEquals(cm.classname, "Sample");
+        Assert.assertEquals(cm.description, "a sample model");
+        Assert.assertEquals(cm.vars.size(), 1);
+        Assert.assertEquals(Sets.union(cm.imports, Sets.newHashSet("Map", "List", "Children")).size(), 3);
+
+        final CodegenProperty property = cm.vars.get(0);
+        Assert.assertEquals(property.baseName, "children");
+        Assert.assertEquals(property.complexType, "Children");
+        Assert.assertEquals(property.getter, "getChildren");
+        Assert.assertEquals(property.setter, "setChildren");
+        Assert.assertEquals(property.datatype, "Map<String, Children>");
+        Assert.assertEquals(property.name, "children");
+        Assert.assertEquals(property.defaultValue, "new HashMap<String, Children>()");
+        Assert.assertEquals(property.baseType, "Map");
+        Assert.assertEquals(property.containerType, "map");
+        Assert.assertNull(property.required);
+        Assert.assertTrue(property.isContainer);
+        Assert.assertNull(property.isNotContainer);
+
+    }
+
+    @Test(description = "convert an array model")
+    public void arrayModelTest() {
+        final Model model = new ArrayModel()
+                .description("an array model")
+                .items(new RefProperty("#/definitions/Children"));
+        final DefaultCodegen codegen = new JavaClientCodegen();
+        final CodegenModel cm = codegen.fromModel("sample", model);
+
+        Assert.assertEquals(cm.name, "sample");
+        Assert.assertEquals(cm.classname, "Sample");
+        Assert.assertEquals(cm.description, "an array model");
+        Assert.assertEquals(cm.vars.size(), 0);
+        Assert.assertEquals(cm.parent, "ArrayList<Children>");
+        Assert.assertEquals(cm.imports.size(), 3);
+        Assert.assertEquals(Sets.union(cm.imports, Sets.newHashSet("List", "ArrayList", "Children")).size(), 3);
+    }
+
+    @Test(description = "convert an map model")
+    public void mapModelTest() {
+        final Model model = new ModelImpl()
+                .description("an map model")
+                .additionalProperties(new RefProperty("#/definitions/Children"));
+        final DefaultCodegen codegen = new JavaClientCodegen();
+        final CodegenModel cm = codegen.fromModel("sample", model);
+
+        Assert.assertEquals(cm.name, "sample");
+        Assert.assertEquals(cm.classname, "Sample");
+        Assert.assertEquals(cm.description, "an map model");
+        Assert.assertEquals(cm.vars.size(), 0);
+        Assert.assertEquals(cm.parent, "HashMap<String, Children>");
+        Assert.assertEquals(cm.imports.size(), 3);
+        Assert.assertEquals(Sets.union(cm.imports, Sets.newHashSet("Map", "HashMap", "Children")).size(), 3);
+    }
+
+    @Test(description = "convert a model with upper-case property names")
+    public void upperCaseNamesTest() {
+        final Model model = new ModelImpl()
+                .description("a model with upper-case property names")
+                .property("NAME", new StringProperty())
+                .required("NAME");
+        final DefaultCodegen codegen = new JavaClientCodegen();
+        final CodegenModel cm = codegen.fromModel("sample", model);
+
+        Assert.assertEquals(cm.name, "sample");
+        Assert.assertEquals(cm.classname, "Sample");
+        Assert.assertEquals(cm.vars.size(), 1);
+
+        final CodegenProperty property = cm.vars.get(0);
+        Assert.assertEquals(property.baseName, "NAME");
+        Assert.assertEquals(property.getter, "getNAME");
+        Assert.assertEquals(property.setter, "setNAME");
+        Assert.assertEquals(property.datatype, "String");
+        Assert.assertEquals(property.name, "NAME");
+        Assert.assertEquals(property.defaultValue, "null");
+        Assert.assertEquals(property.baseType, "String");
+        Assert.assertNull(property.hasMore);
+        Assert.assertTrue(property.required);
+        Assert.assertTrue(property.isNotContainer);
+    }
+
+    @Test(description = "convert a model with a 2nd char upper-case property names")
+    public void secondCharUpperCaseNamesTest() {
+        final Model model = new ModelImpl()
+                .description("a model with a 2nd char upper-case property names")
+                .property("pId", new StringProperty())
+                .required("pId");
+        final DefaultCodegen codegen = new JavaClientCodegen();
+        final CodegenModel cm = codegen.fromModel("sample", model);
+
+        Assert.assertEquals(cm.name, "sample");
+        Assert.assertEquals(cm.classname, "Sample");
+        Assert.assertEquals(cm.vars.size(), 1);
+
+        final CodegenProperty property = cm.vars.get(0);
+        Assert.assertEquals(property.baseName, "pId");
+        Assert.assertEquals(property.getter, "getPId");
+        Assert.assertEquals(property.setter, "setPId");
+        Assert.assertEquals(property.datatype, "String");
+        Assert.assertEquals(property.name, "pId");
+        Assert.assertEquals(property.defaultValue, "null");
+        Assert.assertEquals(property.baseType, "String");
+        Assert.assertNull(property.hasMore);
+        Assert.assertTrue(property.required);
+        Assert.assertTrue(property.isNotContainer);
+    }
+
+    @Test(description = "convert hyphens per issue 503")
+    public void hyphensTest() {
+        final Model model = new ModelImpl()
+                .description("a sample model")
+                .property("created-at", new DateTimeProperty());
+        final DefaultCodegen codegen = new JavaClientCodegen();
+        final CodegenModel cm = codegen.fromModel("sample", model);
+
+        final CodegenProperty property = cm.vars.get(0);
+        Assert.assertEquals(property.baseName, "created-at");
+        Assert.assertEquals(property.getter, "getCreatedAt");
+        Assert.assertEquals(property.setter, "setCreatedAt");
+        Assert.assertEquals(property.name, "createdAt");
+    }
+
+    @Test(description = "convert query[password] to queryPassword")
+    public void squareBracketsTest() {
+        final Model model = new ModelImpl()
+                .description("a sample model")
+                .property("query[password]", new StringProperty());
+        final DefaultCodegen codegen = new JavaClientCodegen();
+        final CodegenModel cm = codegen.fromModel("sample", model);
+
+        final CodegenProperty property = cm.vars.get(0);
+        Assert.assertEquals(property.baseName, "query[password]");
+        Assert.assertEquals(property.getter, "getQueryPassword");
+        Assert.assertEquals(property.setter, "setQueryPassword");
+        Assert.assertEquals(property.name, "queryPassword");
+    }
+
+    @Test(description = "properly escape names per 567")
+    public void escapeNamesTest() {
+        final Model model = new ModelImpl()
+                .description("a sample model")
+                .property("created-at", new DateTimeProperty());
+        final DefaultCodegen codegen = new JavaClientCodegen();
+        final CodegenModel cm = codegen.fromModel("with.dots", model);
+
+        Assert.assertEquals(cm.classname, "WithDots");
+    }
+
+    @Test(description = "convert a model with binary data")
+    public void binaryDataTest() {
+        final Model model = new ModelImpl()
+                .description("model with binary")
+                .property("inputBinaryData", new ByteArrayProperty());
+        final DefaultCodegen codegen = new JavaClientCodegen();
+        final CodegenModel cm = codegen.fromModel("sample", model);
+
+        final CodegenProperty property = cm.vars.get(0);
+        Assert.assertEquals(property.baseName, "inputBinaryData");
+        Assert.assertEquals(property.getter, "getInputBinaryData");
+        Assert.assertEquals(property.setter, "setInputBinaryData");
+        Assert.assertEquals(property.datatype, "byte[]");
+        Assert.assertEquals(property.name, "inputBinaryData");
+        Assert.assertEquals(property.defaultValue, "null");
+        Assert.assertEquals(property.baseType, "byte[]");
+        Assert.assertNull(property.hasMore);
+        Assert.assertNull(property.required);
+        Assert.assertTrue(property.isNotContainer);
+    }
+
+    @Test(description = "translate an invalid param name")
+    public void invalidParamNameTest() {
+        final Model model = new ModelImpl()
+                .description("a model with a 2nd char upper-case property names")
+                .property("_", new StringProperty());
+        final DefaultCodegen codegen = new JavaClientCodegen();
+        final CodegenModel cm = codegen.fromModel("sample", model);
+
+        Assert.assertEquals(cm.name, "sample");
+        Assert.assertEquals(cm.classname, "Sample");
+        Assert.assertEquals(cm.vars.size(), 1);
+
+        final CodegenProperty property = cm.vars.get(0);
+        Assert.assertEquals(property.baseName, "_");
+        Assert.assertEquals(property.getter, "getU");
+        Assert.assertEquals(property.setter, "setU");
+        Assert.assertEquals(property.datatype, "String");
+        Assert.assertEquals(property.name, "u");
+        Assert.assertEquals(property.defaultValue, "null");
+        Assert.assertEquals(property.baseType, "String");
+        Assert.assertNull(property.hasMore);
+        Assert.assertTrue(property.isNotContainer);
+    }
+
+    @Test(description = "convert a parameter")
+    public void convertParameterTest() {
+        final QueryParameter parameter = new QueryParameter()
+                .property(new IntegerProperty())
+                .name("limit")
+                .required(true);
+        final DefaultCodegen codegen = new JavaClientCodegen();
+        final CodegenParameter cm = codegen.fromParameter(parameter, null);
+
+        Assert.assertNull(cm.allowableValues);
+    }
+}