/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.32.1.6535.66c005ced modeling language!*/
////---- Tests for LazyAttribute ----/////
test LazyA {
generate JUnit ;
depend LazyA ;
GIVEN:
LazyAttribute.ump;
THEN:
//tests for :id
test attribute_lazy_id {
LazyA aLazyA();
assertTrue (aLazyA.getId() == null );
assertTrue( aLazyA.setId("RandomString1"));
assertTrue( aLazyA.getId() =="RandomString1");
assertTrue( aLazyA.setId("RandomString2"));
assertTrue( aLazyA.getId()=="RandomString2");
assertFalse( aLazyA.getId() =="RandomString1");
}
}
null
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.32.1.6535.66c005ced modeling language!*/
////---- Tests for OptionalOneToManyAssociation ----/////
test A {
generate JUnit ;
depend A,B ;
GIVEN:
OptionalOneToManyAssociation.ump;
THEN:
//tests for :att1
test attribute_att1 {
A aA("RandomString1");
assertTrue( aA.setAtt1("RandomString1"));
assertTrue( aA.getAtt1() =="RandomString1");
assertTrue( aA.setAtt1("RandomString2"));
assertTrue( aA.getAtt1()=="RandomString2");
assertFalse( aA.getAtt1() =="RandomString1");
}
}
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.32.1.6535.66c005ced modeling language!*/
////---- Tests for OptionalOneToManyAssociation ----/////
test B {
generate JUnit ;
depend A,B ;
GIVEN:
OptionalOneToManyAssociation.ump;
THEN:
//tests for :att2
test attribute_att2 {
B aB("RandomString1");
assertTrue( aB.setAtt2("RandomString1"));
assertTrue( aB.getAtt2() =="RandomString1");
assertTrue( aB.setAtt2("RandomString2"));
assertTrue( aB.getAtt2()=="RandomString2");
assertFalse( aB.getAtt2() =="RandomString1");
}
}
null
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.32.1.6535.66c005ced modeling language!*/
////---- Tests for GenericTestCase_association_optionalOneToOne ----/////
test Calculator {
generate JUnit ;
depend Calculator,Number,Level3,Controller ;
GIVEN:
GenericTestCase_association_optionalOneToOne.ump;
THEN:
//tests for :name
test attribute_name {
Number aNumber("RandomString1",aController);
Calculator aCalculator("RandomString1","RandomString1",123,aNumber);
assertTrue( aCalculator.setName("RandomString1"));
assertTrue( aCalculator.getName() =="RandomString1");
assertTrue( aCalculator.setName("RandomString2"));
assertTrue( aCalculator.getName()=="RandomString2");
assertFalse( aCalculator.getName() =="RandomString1");
}
//tests for :address
test attribute_address {
Number aNumber("RandomString1",aController);
Calculator aCalculator("RandomString1","RandomString1",123,aNumber);
assertTrue( aCalculator.setAddress("RandomString1"));
assertTrue( aCalculator.getAddress() =="RandomString1");
assertTrue( aCalculator.setAddress("RandomString2"));
assertTrue( aCalculator.getAddress()=="RandomString2");
assertFalse( aCalculator.getAddress() =="RandomString1");
}
//tests for :someNO
test attribute_someNO {
}
//tests for :numbers
test attribute_numbers {
Number aNumber("RandomString1",aController);
Calculator aCalculator("RandomString1","RandomString1",123,aNumber);
assertTrue( aCalculator.setNumbers(123));
assertTrue( aCalculator.getNumbers() == 123);
assertTrue( aCalculator.setNumbers(321));
assertTrue( aCalculator.getNumbers() == 321);
assertFalse( aCalculator.getNumbers() == 123);
}
//------------------
//User-defined Tests
//------------------
test checkifLogged_number {
Calculator c1 ( 4, 5) ;
String valueToCheck = p1.getNumber();
Number tempNumbe = number;
}
}
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.32.1.6535.66c005ced modeling language!*/
////---- Tests for GenericTestCase_association_optionalOneToOne ----/////
test Number {
generate JUnit ;
depend Calculator,Number,Level3,Controller ;
GIVEN:
GenericTestCase_association_optionalOneToOne.ump;
THEN:
//tests for :id
test attribute_id {
Controller aController("RandomString1",aLevel3);
Number aNumber("RandomString1",aController);
assertTrue( aNumber.setId("RandomString1"));
assertTrue( aNumber.getId() =="RandomString1");
assertTrue( aNumber.setId("RandomString2"));
assertTrue( aNumber.getId()=="RandomString2");
assertFalse( aNumber.getId() =="RandomString1");
}
}
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.32.1.6535.66c005ced modeling language!*/
////---- Tests for GenericTestCase_association_optionalOneToOne ----/////
test Level3 {
generate JUnit ;
depend Calculator,Number,Level3,Controller ;
GIVEN:
GenericTestCase_association_optionalOneToOne.ump;
THEN:
}
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.32.1.6535.66c005ced modeling language!*/
////---- Tests for GenericTestCase_association_optionalOneToOne ----/////
test Controller {
generate JUnit ;
depend Calculator,Number,Level3,Controller ;
GIVEN:
GenericTestCase_association_optionalOneToOne.ump;
THEN:
//tests for :serialNo
test attribute_serialNo {
Level3 aLevel3();
Controller aController("RandomString1",aLevel3);
assertTrue( aController.setSerialNo("RandomString1"));
assertTrue( aController.getSerialNo() =="RandomString1");
assertTrue( aController.setSerialNo("RandomString2"));
assertTrue( aController.getSerialNo()=="RandomString2");
assertFalse( aController.getSerialNo() =="RandomString1");
}
}
null
father has tests
addddd
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.32.1.6535.66c005ced modeling language!*/
////---- Tests for TestCase_AnscestralTest ----/////
test Person {
generate JUnit ;
depend Person,Student ;
GIVEN:
TestCase_AnscestralTest.ump;
THEN:
//------------------
//User-defined Tests
//------------------
test checkName {
//Father test
assertTrue(id == 1);
}
}
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.32.1.6535.66c005ced modeling language!*/
////---- Tests for TestCase_AnscestralTest ----/////
test Student {
generate JUnit ;
depend Person,Student ;
GIVEN:
TestCase_AnscestralTest.ump;
THEN:
//------------------
//User-defined Tests
//------------------
test checkId {
}
}
null
father has tests
addddd
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.32.1.6535.66c005ced modeling language!*/
////---- Tests for OneToManyAssociation ----/////
test B {
generate JUnit ;
depend B,C,Z,X,A ;
GIVEN:
OneToManyAssociation.ump;
THEN:
}
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.32.1.6535.66c005ced modeling language!*/
////---- Tests for OneToManyAssociation ----/////
test C {
generate JUnit ;
depend B,C,Z,X,A ;
GIVEN:
OneToManyAssociation.ump;
THEN:
}
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.32.1.6535.66c005ced modeling language!*/
////---- Tests for OneToManyAssociation ----/////
test Z {
generate JUnit ;
depend B,C,Z,X,A ;
GIVEN:
OneToManyAssociation.ump;
THEN:
}
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.32.1.6535.66c005ced modeling language!*/
////---- Tests for OneToManyAssociation ----/////
test X {
generate JUnit ;
depend B,C,Z,X,A ;
GIVEN:
OneToManyAssociation.ump;
THEN:
}
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.32.1.6535.66c005ced modeling language!*/
////---- Tests for OneToManyAssociation ----/////
test A {
generate JUnit ;
depend B,C,Z,X,A ;
GIVEN:
OneToManyAssociation.ump;
THEN:
//tests for :id
test attribute_id {
B aB(aC);
A aA("RandomString1",aB);
assertTrue( aA.setId("RandomString1"));
assertTrue( aA.getId() =="RandomString1");
assertTrue( aA.setId("RandomString2"));
assertTrue( aA.getId()=="RandomString2");
assertFalse( aA.getId() =="RandomString1");
}
}
null
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.32.1.6535.66c005ced modeling language!*/
////---- Tests for TraitAssertion_multipleTraits ----/////
test Person {
generate JUnit ;
depend Person ;
GIVEN:
TraitAssertion_multipleTraits.ump;
THEN:
//tests for :firstName
test attribute_firstName {
Person aPerson();
assertTrue( aPerson.setFirstName("RandomString1"));
assertTrue( aPerson.getFirstName() =="RandomString1");
assertTrue( aPerson.setFirstName("RandomString2"));
assertTrue( aPerson.getFirstName()=="RandomString2");
assertFalse( aPerson.getFirstName() =="RandomString1");
}
//------------------
//User-defined Tests
//------------------
test firstCheckName {
assertFalse(firstName == "Orlean");
assertTrue(firstName == "KingEdward");
}
test secondCheckName {
assertFalse(firstName == "SecOrlean");
assertTrue(firstName == "SecondEdward");
}
test thirsdCheckName {
assertFalse(firstName == "ThirdOrlean");
assertTrue(firstName == "ThirdEdwardEdward");
}
}
null
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.32.1.6535.66c005ced modeling language!*/
////---- Tests for TestCase_AbstractTest ----/////
abstract test Person {
generate JUnit ;
depend Person ;
GIVEN:
TestCase_AbstractTest.ump;
THEN:
//------------------
//User-defined Tests
//------------------
test checkName {
//Father test
assertTrue(id == 1);
}
}
null
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.32.1.6535.66c005ced modeling language!*/
////---- Tests for immutableAttribute ----/////
test ImmutableA {
generate JUnit ;
depend ImmutableA ;
GIVEN:
immutableAttribute.ump;
THEN:
//tests for :id
test attribute_immutable_id {
ImmutableA aImmutableA();
//assertMethod(setId());
assertTrue( aImmutableA.getId() == "someId");
}
}
null
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.32.1.6535.66c005ced modeling language!*/
////---- Tests for TraitAssertion_SameTestMultipleTraits ----/////
test Person {
generate JUnit ;
depend Person ;
GIVEN:
TraitAssertion_SameTestMultipleTraits.ump;
THEN:
//tests for :firstName
test attribute_firstName {
Person aPerson();
assertTrue( aPerson.setFirstName("RandomString1"));
assertTrue( aPerson.getFirstName() =="RandomString1");
assertTrue( aPerson.setFirstName("RandomString2"));
assertTrue( aPerson.getFirstName()=="RandomString2");
assertFalse( aPerson.getFirstName() =="RandomString1");
}
//------------------
//User-defined Tests
//------------------
test checkName {
assertFalse(firstName == "Orlean");
assertTrue(firstName == "KingEdward");
assertFalse(firstName == "SecOrlean");
assertTrue(firstName == "SecondEdward");
assertFalse(firstName == "ThirdOrlean");
assertTrue(firstName == "ThirdEdwardEdward");
}
}
null
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.32.1.6535.66c005ced modeling language!*/
////---- Tests for TestSequence_noTestCases ----/////
test Person {
generate JUnit ;
depend Person ;
GIVEN:
TestSequence_noTestCases.ump;
THEN:
}
null
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.32.1.6535.66c005ced modeling language!*/
////---- Tests for MixsetTest ----/////
test Person {
generate JUnit ;
depend Person ;
GIVEN:
MixsetTest.ump;
THEN:
//tests for :x
test attribute_x {
Person aPerson("RandomString1");
assertTrue( aPerson.setX("RandomString1"));
assertTrue( aPerson.getX() =="RandomString1");
assertTrue( aPerson.setX("RandomString2"));
assertTrue( aPerson.getX()=="RandomString2");
assertFalse( aPerson.getX() =="RandomString1");
}
//------------------
//User-defined Tests
//------------------
test checkName {
assertFalse(firstName == "Orlean");
assertTrue(firstName == "KingEdward");
}
}
null
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.32.1.6535.66c005ced modeling language!*/
////---- Tests for GenericTestCase_String ----/////
test Person {
generate JUnit ;
depend Person ;
GIVEN:
GenericTestCase_String.ump;
THEN:
//tests for :id
test attribute_id {
Person aPerson(123,"RandomString1","unidentified");
assertTrue( aPerson.setId(123));
assertTrue( aPerson.getId() == 123);
assertTrue( aPerson.setId(321));
assertTrue( aPerson.getId() == 321);
assertFalse( aPerson.getId() == 123);
}
//tests for :name
test attribute_name {
Person aPerson(123,"RandomString1","unidentified");
assertTrue( aPerson.setName("RandomString1"));
assertTrue( aPerson.getName() =="RandomString1");
assertTrue( aPerson.setName("RandomString2"));
assertTrue( aPerson.getName()=="RandomString2");
assertFalse( aPerson.getName() =="RandomString1");
}
//tests for :postal
test attribute_postal {
Person aPerson(123,"RandomString1","unidentified");
assertTrue( aPerson.setPostal(123456789));
assertTrue( aPerson.getPostal() == 123456789);
assertTrue( aPerson.setPostal(987654321));
assertTrue( aPerson.getPostal() == 987654321);
assertFalse( aPerson.getPostal() == 123456789);
}
//------------------
//User-defined Tests
//------------------
test checkifLogged_name {
Person p1 ( "S1425", "John", "Ottawa") ;
String valueToCheck = p1.getName();
ps1.getValue(name);
boolean isLogged = p1.checkIsLogged(valueToCheck);
assertTrue(logged == "true");
}
}
null
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.32.1.6535.66c005ced modeling language!*/
////---- Tests for GenericTestCase_association_oneToMany_RNav ----/////
test Calculator {
generate JUnit ;
depend Calculator,Number,Controller ;
GIVEN:
GenericTestCase_association_oneToMany_RNav.ump;
THEN:
//------------------
//User-defined Tests
//------------------
test checkifLogged_numbers {
Calculator c1 ( 4, 5) ;
String valueToCheck = p1.getNumbers();
Number tempNumber = numbers;
}
}
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.32.1.6535.66c005ced modeling language!*/
////---- Tests for GenericTestCase_association_oneToMany_RNav ----/////
test Number {
generate JUnit ;
depend Calculator,Number,Controller ;
GIVEN:
GenericTestCase_association_oneToMany_RNav.ump;
THEN:
}
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.32.1.6535.66c005ced modeling language!*/
////---- Tests for GenericTestCase_association_oneToMany_RNav ----/////
test Controller {
generate JUnit ;
depend Calculator,Number,Controller ;
GIVEN:
GenericTestCase_association_oneToMany_RNav.ump;
THEN:
}
null
true
true
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.32.1.6535.66c005ced modeling language!*/
////---- Tests for GenericTestCase_association_optionalOneToMany ----/////
test Calculator {
generate JUnit ;
depend Calculator,Number,Controller ;
GIVEN:
GenericTestCase_association_optionalOneToMany.ump;
THEN:
//------------------
//User-defined Tests
//------------------
test checkifLogged_controllers {
Calculator c1 ( 4, 5) ;
String valueToCheck = p1.getControllers();
Number tempController = controllers;
}
}
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.32.1.6535.66c005ced modeling language!*/
////---- Tests for GenericTestCase_association_optionalOneToMany ----/////
test Number {
generate JUnit ;
depend Calculator,Number,Controller ;
GIVEN:
GenericTestCase_association_optionalOneToMany.ump;
THEN:
}
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.32.1.6535.66c005ced modeling language!*/
////---- Tests for GenericTestCase_association_optionalOneToMany ----/////
test Controller {
generate JUnit ;
depend Calculator,Number,Controller ;
GIVEN:
GenericTestCase_association_optionalOneToMany.ump;
THEN:
}
null
true
true
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.32.1.6535.66c005ced modeling language!*/
////---- Tests for TraitAssertion ----/////
test Person {
generate JUnit ;
depend Person ;
GIVEN:
TraitAssertion.ump;
THEN:
//tests for :firstName
test attribute_firstName {
Person aPerson();
assertTrue( aPerson.setFirstName("RandomString1"));
assertTrue( aPerson.getFirstName() =="RandomString1");
assertTrue( aPerson.setFirstName("RandomString2"));
assertTrue( aPerson.getFirstName()=="RandomString2");
assertFalse( aPerson.getFirstName() =="RandomString1");
}
//------------------
//User-defined Tests
//------------------
test checkName {
assertFalse(firstName == "Orlean");
assertTrue(firstName == "KingEdward");
}
}
null
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.32.1.6535.66c005ced modeling language!*/
////---- Tests for TestCaseAction ----/////
test Job {
generate JUnit ;
depend Job,Organization,Score,Person ;
GIVEN:
TestCaseAction.ump;
THEN:
//tests for :name
test attribute_name {
Person aPerson(aOrganization);
Job aJob("RandomString1",aPerson);
assertTrue( aJob.setName("RandomString1"));
assertTrue( aJob.getName() =="RandomString1");
assertTrue( aJob.setName("RandomString2"));
assertTrue( aJob.getName()=="RandomString2");
assertFalse( aJob.getName() =="RandomString1");
}
}
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.32.1.6535.66c005ced modeling language!*/
////---- Tests for TestCaseAction ----/////
test Organization {
generate JUnit ;
depend Job,Organization,Score,Person ;
GIVEN:
TestCaseAction.ump;
THEN:
}
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.32.1.6535.66c005ced modeling language!*/
////---- Tests for TestCaseAction ----/////
test Score {
generate JUnit ;
depend Job,Organization,Score,Person ;
GIVEN:
TestCaseAction.ump;
THEN:
//tests for :score
test attribute_score {
Person aPerson(aOrganization);
Score aScore(123,aPerson);
assertTrue( aScore.setScore(123));
assertTrue( aScore.getScore() == 123);
assertTrue( aScore.setScore(321));
assertTrue( aScore.getScore() == 321);
assertFalse( aScore.getScore() == 123);
}
}
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.32.1.6535.66c005ced modeling language!*/
/*
All person cannot have a Coash as a job.
*/
////---- Tests for TestCaseAction ----/////
test Person {
generate JUnit ;
depend Job,Organization,Score,Person ;
GIVEN:
TestCaseAction.ump;
WHERE:
Person p1 ("john", 123);
Job j1 ("Cashier");
THEN:
before { setUp }
before { teardown }
//------------------
//User-defined Tests
//------------------
test checkForLoop {
Person p1 (123);
ArrayList<Job> jobs = p1.getJobs();
Integer size = jobs.size();
for ( Job job : jobs )
{
assertTrue(job.getName() != "Coach");
}
}
test checkStatus {
//----------------
//before assertions
//----------------
AssertFalse(d1.firstName() == "Orlean");
//End of before assertions
//something
Person p1 ("id");
id = "id";
String id2 = p1.getGate(id,"name");
String id2 = p1.getGate();
String id2 = getGate();
String id2 = getGate(id);
p1.openGarage(p1);
openGarage(p1);
this.setId("id",id);
//assertion comment
/*multiline comment
line comment*/
//----------------
//after assertions
//----------------
AssertFalse(p1.getId() == "something");
//End of after assertions
}
test checkCashierPromotion {
//----------------
//before assertions
//----------------
AssertTrue(job.getName == "Cashier");
//End of before assertions
job1.promote();
//----------------
//after assertions
//----------------
AssertTrue(jobName == "Manager");
//End of after assertions
}
test setUp {
//initalize enviroment
}
test teardown {
//delete files
}
after { setUp }
after { teardown }
}
null
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.32.1.6535.66c005ced modeling language!*/
////---- Tests for ifStatementTest ----/////
test Person {
generate JUnit ;
depend Person ;
GIVEN:
ifStatementTest.ump;
THEN:
//tests for :name
test attribute_name {
Person aPerson("RandomString1",123,"RandomString1");
assertTrue( aPerson.setName("RandomString1"));
assertTrue( aPerson.getName() =="RandomString1");
assertTrue( aPerson.setName("RandomString2"));
assertTrue( aPerson.getName()=="RandomString2");
assertFalse( aPerson.getName() =="RandomString1");
}
//tests for :id
test attribute_id {
Person aPerson("RandomString1",123,"RandomString1");
assertTrue( aPerson.setId(123));
assertTrue( aPerson.getId() == 123);
assertTrue( aPerson.setId(321));
assertTrue( aPerson.getId() == 321);
assertFalse( aPerson.getId() == 123);
}
//tests for :Job
test attribute_Job {
Person aPerson("RandomString1",123,"RandomString1");
assertTrue( aPerson.setJob("RandomString1"));
assertTrue( aPerson.getJob() =="RandomString1");
assertTrue( aPerson.setJob("RandomString2"));
assertTrue( aPerson.getJob()=="RandomString2");
assertFalse( aPerson.getJob() =="RandomString1");
}
//------------------
//User-defined Tests
//------------------
test checkIfStatement {
String tempId = p1.getId();
String job = p1.getJob();
if(tempId == 1324){
assertTrue (job.getName() == "Saleman");
}
}
}
null
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.32.1.6535.66c005ced modeling language!*/
////---- Tests for GenericTestCase ----/////
test Person {
generate JUnit ;
depend Person ;
GIVEN:
GenericTestCase.ump;
WHERE:
Student st (9999, 9999);
THEN:
//tests for :id
test attribute_id {
Person aPerson("RandomString1","RandomString1","RandomString1");
assertTrue( aPerson.setId("RandomString1"));
assertTrue( aPerson.getId() =="RandomString1");
assertTrue( aPerson.setId("RandomString2"));
assertTrue( aPerson.getId()=="RandomString2");
assertFalse( aPerson.getId() =="RandomString1");
}
//tests for :name
test attribute_name {
Person aPerson("RandomString1","RandomString1","RandomString1");
assertTrue( aPerson.setName("RandomString1"));
assertTrue( aPerson.getName() =="RandomString1");
assertTrue( aPerson.setName("RandomString2"));
assertTrue( aPerson.getName()=="RandomString2");
assertFalse( aPerson.getName() =="RandomString1");
}
//tests for :address
test attribute_address {
Person aPerson("RandomString1","RandomString1","RandomString1");
assertTrue( aPerson.setAddress("RandomString1"));
assertTrue( aPerson.getAddress() =="RandomString1");
assertTrue( aPerson.setAddress("RandomString2"));
assertTrue( aPerson.getAddress()=="RandomString2");
assertFalse( aPerson.getAddress() =="RandomString1");
}
//------------------
//User-defined Tests
//------------------
test checkifLogged_id {
Person p1 ( "S1425", "John", "Ottawa") ;
String valueToCheck = p1.getId();
ps1.getValue(id);
boolean isLogged = p1.checkIsLogged(valueToCheck);
assertTrue(logged == "true");
}
test checkifLogged_name {
Person p1 ( "S1425", "John", "Ottawa") ;
String valueToCheck = p1.getName();
ps1.getValue(name);
boolean isLogged = p1.checkIsLogged(valueToCheck);
assertTrue(logged == "true");
}
test checkifLogged_address {
Person p1 ( "S1425", "John", "Ottawa") ;
String valueToCheck = p1.getAddress();
ps1.getValue(address);
boolean isLogged = p1.checkIsLogged(valueToCheck);
assertTrue(logged == "true");
}
}
null
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.32.1.6535.66c005ced modeling language!*/
////---- Tests for elseStatementTest ----/////
test Person {
generate JUnit ;
depend Person ;
GIVEN:
elseStatementTest.ump;
THEN:
//tests for :name
test attribute_name {
Person aPerson("RandomString1","RandomString1","RandomString1");
assertTrue( aPerson.setName("RandomString1"));
assertTrue( aPerson.getName() =="RandomString1");
assertTrue( aPerson.setName("RandomString2"));
assertTrue( aPerson.getName()=="RandomString2");
assertFalse( aPerson.getName() =="RandomString1");
}
//tests for :job
test attribute_job {
Person aPerson("RandomString1","RandomString1","RandomString1");
assertTrue( aPerson.setJob("RandomString1"));
assertTrue( aPerson.getJob() =="RandomString1");
assertTrue( aPerson.setJob("RandomString2"));
assertTrue( aPerson.getJob()=="RandomString2");
assertFalse( aPerson.getJob() =="RandomString1");
}
//tests for :id
test attribute_id {
Person aPerson("RandomString1","RandomString1","RandomString1");
assertTrue( aPerson.setId("RandomString1"));
assertTrue( aPerson.getId() =="RandomString1");
assertTrue( aPerson.setId("RandomString2"));
assertTrue( aPerson.getId()=="RandomString2");
assertFalse( aPerson.getId() =="RandomString1");
}
//------------------
//User-defined Tests
//------------------
test checkJobBasedOnId {
Person p1 ("John", "Cashier", 9780);
String tempId = p1.getId();
String job = p1.getJob();
if(tempId == 1234){
assertTrue (job == "Saleman");
}
else {
assertFalse (job == "Saleman");
}
}
}
null
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.32.1.6535.66c005ced modeling language!*/
////---- Tests for interfaceTest ----/////
test Person {
generate JUnit ;
depend Person,CorporateClient,IndividualStudent,Course ;
GIVEN:
interfaceTest.ump;
THEN:
//tests for :name
test attribute_name {
Person aPerson("RandomString1");
assertTrue( aPerson.setName("RandomString1"));
assertTrue( aPerson.getName() =="RandomString1");
assertTrue( aPerson.setName("RandomString2"));
assertTrue( aPerson.getName()=="RandomString2");
assertFalse( aPerson.getName() =="RandomString1");
}
}
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.32.1.6535.66c005ced modeling language!*/
////---- Tests for interfaceTest ----/////
test CorporateClient {
generate JUnit ;
depend Person,CorporateClient,IndividualStudent,Course ;
GIVEN:
interfaceTest.ump;
THEN:
}
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.32.1.6535.66c005ced modeling language!*/
////---- Tests for interfaceTest ----/////
test IndividualStudent {
generate JUnit ;
depend Person,CorporateClient,IndividualStudent,Course ;
GIVEN:
interfaceTest.ump;
THEN:
}
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.32.1.6535.66c005ced modeling language!*/
////---- Tests for interfaceTest ----/////
test Course {
generate JUnit ;
depend Person,CorporateClient,IndividualStudent,Course ;
GIVEN:
interfaceTest.ump;
THEN:
//tests for :name
test attribute_name {
Course aCourse("RandomString1","RandomString1");
assertTrue( aCourse.setName("RandomString1"));
assertTrue( aCourse.getName() =="RandomString1");
assertTrue( aCourse.setName("RandomString2"));
assertTrue( aCourse.getName()=="RandomString2");
assertFalse( aCourse.getName() =="RandomString1");
}
//tests for :description
test attribute_description {
Course aCourse("RandomString1","RandomString1");
assertTrue( aCourse.setDescription("RandomString1"));
assertTrue( aCourse.getDescription() =="RandomString1");
assertTrue( aCourse.setDescription("RandomString2"));
assertTrue( aCourse.getDescription()=="RandomString2");
assertFalse( aCourse.getDescription() =="RandomString1");
}
}
null
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.32.1.6535.66c005ced modeling language!*/
////---- Tests for GenericTestCase_association_oneToMany ----/////
test Calculator {
generate JUnit ;
depend Calculator,Number,Controller ;
GIVEN:
GenericTestCase_association_oneToMany.ump;
THEN:
//------------------
//User-defined Tests
//------------------
test checkifLogged_numbers {
Calculator c1 ( 4, 5) ;
String valueToCheck = p1.getNumbers();
Number tempNumber = numbers;
}
}
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.32.1.6535.66c005ced modeling language!*/
////---- Tests for GenericTestCase_association_oneToMany ----/////
test Number {
generate JUnit ;
depend Calculator,Number,Controller ;
GIVEN:
GenericTestCase_association_oneToMany.ump;
THEN:
}
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.32.1.6535.66c005ced modeling language!*/
////---- Tests for GenericTestCase_association_oneToMany ----/////
test Controller {
generate JUnit ;
depend Calculator,Number,Controller ;
GIVEN:
GenericTestCase_association_oneToMany.ump;
THEN:
}
null
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.32.1.6535.66c005ced modeling language!*/
////---- Tests for GenericTestCase_method ----/////
test Calculator {
generate JUnit ;
depend Calculator ;
GIVEN:
GenericTestCase_method.ump;
THEN:
//tests for :x
test attribute_x {
Calculator aCalculator(123,123);
assertTrue( aCalculator.setX(123));
assertTrue( aCalculator.getX() == 123);
assertTrue( aCalculator.setX(321));
assertTrue( aCalculator.getX() == 321);
assertFalse( aCalculator.getX() == 123);
}
//tests for :y
test attribute_y {
Calculator aCalculator(123,123);
assertTrue( aCalculator.setY(123));
assertTrue( aCalculator.getY() == 123);
assertTrue( aCalculator.setY(321));
assertTrue( aCalculator.getY() == 321);
assertFalse( aCalculator.getY() == 123);
}
//------------------
//User-defined Tests
//------------------
test checkifLogged_returnInteger {
Calculator c1 ( 4, 5) ;
String valueToCheck = p1.getreturnInteger();
ps1.getValue(returnInteger);
boolean isLogged = p1.checkIsLogged(valueToCheck);
assertTrue(logged == "true");
}
test checkifLogged_returnStirng {
// code omitted
}
}
null
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.32.1.6535.66c005ced modeling language!*/
////---- Tests for MixsetTest_multiple ----/////
test Person {
generate JUnit ;
depend Person ;
GIVEN:
MixsetTest_multiple.ump;
THEN:
//tests for :x
test attribute_x {
Person aPerson("RandomString1");
assertTrue( aPerson.setX("RandomString1"));
assertTrue( aPerson.getX() =="RandomString1");
assertTrue( aPerson.setX("RandomString2"));
assertTrue( aPerson.getX()=="RandomString2");
assertFalse( aPerson.getX() =="RandomString1");
}
//------------------
//User-defined Tests
//------------------
test checkName {
assertFalse(firstName == "Orlean");
assertTrue(firstName == "KingEdward");
}
test secondCheckName {
assertFalse(firstName == "Orlean");
assertTrue(firstName == "KingEdward");
}
}
null
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.32.1.6535.66c005ced modeling language!*/
////---- Tests for GenericTestCase_association_manyToMany ----/////
test Calculator {
generate JUnit ;
depend Calculator,Number,Controller ;
GIVEN:
GenericTestCase_association_manyToMany.ump;
THEN:
//------------------
//User-defined Tests
//------------------
test checkifLogged_numbers {
Calculator c1 ( 4, 5) ;
String valueToCheck = p1.getNumbers();
Number tempNumber = numbers;
}
}
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.32.1.6535.66c005ced modeling language!*/
////---- Tests for GenericTestCase_association_manyToMany ----/////
test Number {
generate JUnit ;
depend Calculator,Number,Controller ;
GIVEN:
GenericTestCase_association_manyToMany.ump;
THEN:
}
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.32.1.6535.66c005ced modeling language!*/
////---- Tests for GenericTestCase_association_manyToMany ----/////
test Controller {
generate JUnit ;
depend Calculator,Number,Controller ;
GIVEN:
GenericTestCase_association_manyToMany.ump;
THEN:
}
null
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.32.1.6535.66c005ced modeling language!*/
////---- Tests for GenericTestCase_attribute_regex ----/////
test Student {
generate JUnit ;
depend Student ;
GIVEN:
GenericTestCase_attribute_regex.ump;
THEN:
//tests for :studentId
test attribute_studentId {
Student aStudent("RandomString1","RandomString1","RandomString1","RandomString1");
assertTrue( aStudent.setStudentId("RandomString1"));
assertTrue( aStudent.getStudentId() =="RandomString1");
assertTrue( aStudent.setStudentId("RandomString2"));
assertTrue( aStudent.getStudentId()=="RandomString2");
assertFalse( aStudent.getStudentId() =="RandomString1");
}
//tests for :nameMemebershipId
test attribute_nameMemebershipId {
Student aStudent("RandomString1","RandomString1","RandomString1","RandomString1");
assertTrue( aStudent.setNameMemebershipId("RandomString1"));
assertTrue( aStudent.getNameMemebershipId() =="RandomString1");
assertTrue( aStudent.setNameMemebershipId("RandomString2"));
assertTrue( aStudent.getNameMemebershipId()=="RandomString2");
assertFalse( aStudent.getNameMemebershipId() =="RandomString1");
}
//tests for :nameMemebershipHouse
test attribute_nameMemebershipHouse {
Student aStudent("RandomString1","RandomString1","RandomString1","RandomString1");
assertTrue( aStudent.setNameMemebershipHouse("RandomString1"));
assertTrue( aStudent.getNameMemebershipHouse() =="RandomString1");
assertTrue( aStudent.setNameMemebershipHouse("RandomString2"));
assertTrue( aStudent.getNameMemebershipHouse()=="RandomString2");
assertFalse( aStudent.getNameMemebershipHouse() =="RandomString1");
}
//tests for :address
test attribute_address {
Student aStudent("RandomString1","RandomString1","RandomString1","RandomString1");
assertTrue( aStudent.setAddress("RandomString1"));
assertTrue( aStudent.getAddress() =="RandomString1");
assertTrue( aStudent.setAddress("RandomString2"));
assertTrue( aStudent.getAddress()=="RandomString2");
assertFalse( aStudent.getAddress() =="RandomString1");
}
//------------------
//User-defined Tests
//------------------
test checkifLogged_nameMemebershipId {
Student st1 ( "S1425", "John", "Ottawa") ;
String valueToCheck = st1.getNameMemebershipId();
st1.getValue(nameMemebershipId);
boolean isLogged = st1.checkIsLogged(valueToCheck);
//list assertions
}
test checkifLogged_nameMemebershipHouse {
Student st1 ( "S1425", "John", "Ottawa") ;
String valueToCheck = st1.getNameMemebershipHouse();
st1.getValue(nameMemebershipHouse);
boolean isLogged = st1.checkIsLogged(valueToCheck);
//list assertions
}
}
null
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.32.1.6535.66c005ced modeling language!*/
////---- Tests for MixsetTest_action ----/////
test Person {
generate JUnit ;
depend Person ;
GIVEN:
MixsetTest_action.ump;
THEN:
//tests for :x
test attribute_x {
Person aPerson("RandomString1");
assertTrue( aPerson.setX("RandomString1"));
assertTrue( aPerson.getX() =="RandomString1");
assertTrue( aPerson.setX("RandomString2"));
assertTrue( aPerson.getX()=="RandomString2");
assertFalse( aPerson.getX() =="RandomString1");
}
//------------------
//User-defined Tests
//------------------
test checkName {
assertFalse(firstName == "Orlean");
this.setId("kingEdward");
assertTrue(firstName == "KingEdward");
}
}
null
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.32.1.6535.66c005ced modeling language!*/
////---- Tests for TestCaseAction_trait ----/////
test Person {
generate JUnit ;
depend Person ;
GIVEN:
TestCaseAction_trait.ump;
THEN:
//tests for :firstName
test attribute_firstName {
Person aPerson();
assertTrue( aPerson.setFirstName("RandomString1"));
assertTrue( aPerson.getFirstName() =="RandomString1");
assertTrue( aPerson.setFirstName("RandomString2"));
assertTrue( aPerson.getFirstName()=="RandomString2");
assertFalse( aPerson.getFirstName() =="RandomString1");
}
//------------------
//User-defined Tests
//------------------
test checkName {
assertFalse(firstName == "Orlean");
this.setId("kingEdward");
assertTrue(firstName == "KingEdward");
}
}
null
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.32.1.6535.66c005ced modeling language!*/
////---- Tests for ClassAssertion ----/////
test ClassAssertion {
generate JUnit ;
depend ClassAssertion ;
GIVEN:
ClassAssertion.ump;
THEN:
//tests for :number
test attribute_number {
ClassAssertion aClassAssertion();
assertEqual(aClassAssertion.getNumber(), 321 );
assertTrue( aClassAssertion.setNumber(123));
assertTrue( aClassAssertion.getNumber() == 123);
assertTrue( aClassAssertion.setNumber(321));
assertTrue( aClassAssertion.getNumber() == 321);
assertFalse( aClassAssertion.getNumber() == 123);
}
//tests for :number2
test attribute_number2 {
ClassAssertion aClassAssertion();
assertEqual(aClassAssertion.getNumber2(), 10 );
assertTrue( aClassAssertion.setNumber2(123));
assertTrue( aClassAssertion.getNumber2() == 123);
assertTrue( aClassAssertion.setNumber2(321));
assertTrue( aClassAssertion.getNumber2() == 321);
assertFalse( aClassAssertion.getNumber2() == 123);
}
//------------------
//User-defined Tests
//------------------
test calculateSomething {
assertTrue(id == "seomthing");
assertFalse(number == 123);
assertEqual(number, number2);
}
}
null
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.32.1.6535.66c005ced modeling language!*/
////---- Tests for GenericTestCase_Integer ----/////
test Student {
generate JUnit ;
depend Student ;
GIVEN:
GenericTestCase_Integer.ump;
THEN:
//tests for :studentId
test attribute_studentId {
Student aStudent("RandomString1","RandomString1","RandomString1");
assertTrue( aStudent.setStudentId("RandomString1"));
assertTrue( aStudent.getStudentId() =="RandomString1");
assertTrue( aStudent.setStudentId("RandomString2"));
assertTrue( aStudent.getStudentId()=="RandomString2");
assertFalse( aStudent.getStudentId() =="RandomString1");
}
//tests for :name
test attribute_name {
Student aStudent("RandomString1","RandomString1","RandomString1");
assertTrue( aStudent.setName("RandomString1"));
assertTrue( aStudent.getName() =="RandomString1");
assertTrue( aStudent.setName("RandomString2"));
assertTrue( aStudent.getName()=="RandomString2");
assertFalse( aStudent.getName() =="RandomString1");
}
//tests for :address
test attribute_address {
Student aStudent("RandomString1","RandomString1","RandomString1");
assertTrue( aStudent.setAddress("RandomString1"));
assertTrue( aStudent.getAddress() =="RandomString1");
assertTrue( aStudent.setAddress("RandomString2"));
assertTrue( aStudent.getAddress()=="RandomString2");
assertFalse( aStudent.getAddress() =="RandomString1");
}
//------------------
//User-defined Tests
//------------------
test checkifLogged_studentId {
Student st1 ( "S1425", "John", "Ottawa") ;
String valueToCheck = st1.getStudentId();
st1.getValue(studentId);
boolean isLogged = st1.checkIsLogged(valueToCheck);
//list assertions
}
test checkifLogged_name {
Student st1 ( "S1425", "John", "Ottawa") ;
String valueToCheck = st1.getName();
st1.getValue(name);
boolean isLogged = st1.checkIsLogged(valueToCheck);
//list assertions
}
test checkifLogged_address {
Student st1 ( "S1425", "John", "Ottawa") ;
String valueToCheck = st1.getAddress();
st1.getValue(address);
boolean isLogged = st1.checkIsLogged(valueToCheck);
//list assertions
}
}
null
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.32.1.6535.66c005ced modeling language!*/
////---- Tests for GenericTestCase_association_optionalOneToOne_RNav ----/////
test Calculator {
generate JUnit ;
depend Calculator,Number,Controller ;
GIVEN:
GenericTestCase_association_optionalOneToOne_RNav.ump;
THEN:
}
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.32.1.6535.66c005ced modeling language!*/
////---- Tests for GenericTestCase_association_optionalOneToOne_RNav ----/////
test Number {
generate JUnit ;
depend Calculator,Number,Controller ;
GIVEN:
GenericTestCase_association_optionalOneToOne_RNav.ump;
THEN:
}
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.32.1.6535.66c005ced modeling language!*/
////---- Tests for GenericTestCase_association_optionalOneToOne_RNav ----/////
test Controller {
generate JUnit ;
depend Calculator,Number,Controller ;
GIVEN:
GenericTestCase_association_optionalOneToOne_RNav.ump;
THEN:
}
null
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.32.1.6535.66c005ced modeling language!*/
////---- Tests for GenericTestCase_association_manyToMany_RNav ----/////
test Calculator {
generate JUnit ;
depend Calculator,Number,Controller ;
GIVEN:
GenericTestCase_association_manyToMany_RNav.ump;
THEN:
//------------------
//User-defined Tests
//------------------
test checkifLogged_numbers {
Calculator c1 ( 4, 5) ;
String valueToCheck = p1.getNumbers();
Number tempNumber = numbers;
}
}
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.32.1.6535.66c005ced modeling language!*/
////---- Tests for GenericTestCase_association_manyToMany_RNav ----/////
test Number {
generate JUnit ;
depend Calculator,Number,Controller ;
GIVEN:
GenericTestCase_association_manyToMany_RNav.ump;
THEN:
}
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.32.1.6535.66c005ced modeling language!*/
////---- Tests for GenericTestCase_association_manyToMany_RNav ----/////
test Controller {
generate JUnit ;
depend Calculator,Number,Controller ;
GIVEN:
GenericTestCase_association_manyToMany_RNav.ump;
THEN:
}
null
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.32.1.6535.66c005ced modeling language!*/
////---- Tests for GenericTestCase_association_optionalOneToMany_RNav ----/////
test Calculator {
generate JUnit ;
depend Calculator,Number,Controller ;
GIVEN:
GenericTestCase_association_optionalOneToMany_RNav.ump;
THEN:
//------------------
//User-defined Tests
//------------------
test checkifLogged_controllers {
Calculator c1 ( 4, 5) ;
String valueToCheck = p1.getControllers();
Number tempController = controllers;
}
}
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.32.1.6535.66c005ced modeling language!*/
////---- Tests for GenericTestCase_association_optionalOneToMany_RNav ----/////
test Number {
generate JUnit ;
depend Calculator,Number,Controller ;
GIVEN:
GenericTestCase_association_optionalOneToMany_RNav.ump;
THEN:
}
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.32.1.6535.66c005ced modeling language!*/
////---- Tests for GenericTestCase_association_optionalOneToMany_RNav ----/////
test Controller {
generate JUnit ;
depend Calculator,Number,Controller ;
GIVEN:
GenericTestCase_association_optionalOneToMany_RNav.ump;
THEN:
}
null
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.32.1.6535.66c005ced modeling language!*/
////---- Tests for GenericTestCase_attribute_prefix ----/////
test Student {
generate JUnit ;
depend Student ;
GIVEN:
GenericTestCase_attribute_prefix.ump;
THEN:
//tests for :studentId
test attribute_studentId {
Student aStudent("RandomString1","RandomString1","RandomString1");
assertTrue( aStudent.setStudentId("RandomString1"));
assertTrue( aStudent.getStudentId() =="RandomString1");
assertTrue( aStudent.setStudentId("RandomString2"));
assertTrue( aStudent.getStudentId()=="RandomString2");
assertFalse( aStudent.getStudentId() =="RandomString1");
}
//tests for :name
test attribute_name {
Student aStudent("RandomString1","RandomString1","RandomString1");
assertTrue( aStudent.setName("RandomString1"));
assertTrue( aStudent.getName() =="RandomString1");
assertTrue( aStudent.setName("RandomString2"));
assertTrue( aStudent.getName()=="RandomString2");
assertFalse( aStudent.getName() =="RandomString1");
}
//tests for :address
test attribute_address {
Student aStudent("RandomString1","RandomString1","RandomString1");
assertTrue( aStudent.setAddress("RandomString1"));
assertTrue( aStudent.getAddress() =="RandomString1");
assertTrue( aStudent.setAddress("RandomString2"));
assertTrue( aStudent.getAddress()=="RandomString2");
assertFalse( aStudent.getAddress() =="RandomString1");
}
//------------------
//User-defined Tests
//------------------
test checkifLogged_studentId {
Student st1 ( "S1425", "John", "Ottawa") ;
String valueToCheck = st1.getStudentId();
st1.getValue(studentId);
boolean isLogged = st1.checkIsLogged(valueToCheck);
//list assertions
}
}
null
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.32.1.6535.66c005ced modeling language!*/
////---- Tests for GenericTestCase_attribute_suffix ----/////
test Student {
generate JUnit ;
depend Student ;
GIVEN:
GenericTestCase_attribute_suffix.ump;
THEN:
//tests for :studentId
test attribute_studentId {
Student aStudent("RandomString1","RandomString1","RandomString1");
assertTrue( aStudent.setStudentId("RandomString1"));
assertTrue( aStudent.getStudentId() =="RandomString1");
assertTrue( aStudent.setStudentId("RandomString2"));
assertTrue( aStudent.getStudentId()=="RandomString2");
assertFalse( aStudent.getStudentId() =="RandomString1");
}
//tests for :name
test attribute_name {
Student aStudent("RandomString1","RandomString1","RandomString1");
assertTrue( aStudent.setName("RandomString1"));
assertTrue( aStudent.getName() =="RandomString1");
assertTrue( aStudent.setName("RandomString2"));
assertTrue( aStudent.getName()=="RandomString2");
assertFalse( aStudent.getName() =="RandomString1");
}
//tests for :address
test attribute_address {
Student aStudent("RandomString1","RandomString1","RandomString1");
assertTrue( aStudent.setAddress("RandomString1"));
assertTrue( aStudent.getAddress() =="RandomString1");
assertTrue( aStudent.setAddress("RandomString2"));
assertTrue( aStudent.getAddress()=="RandomString2");
assertFalse( aStudent.getAddress() =="RandomString1");
}
//------------------
//User-defined Tests
//------------------
test checkifLogged_studentId {
Student st1 ( "S1425", "John", "Ottawa") ;
String valueToCheck = st1.getStudentId();
st1.getValue(studentId);
boolean isLogged = st1.checkIsLogged(valueToCheck);
//list assertions
}
}
null
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.32.1.6535.66c005ced modeling language!*/
////---- Tests for ifElseStatementTest ----/////
test Person {
generate JUnit ;
depend Person ;
GIVEN:
ifElseStatementTest.ump;
THEN:
//tests for :name
test attribute_name {
Person aPerson("RandomString1","RandomString1",123);
assertTrue( aPerson.setName("RandomString1"));
assertTrue( aPerson.getName() =="RandomString1");
assertTrue( aPerson.setName("RandomString2"));
assertTrue( aPerson.getName()=="RandomString2");
assertFalse( aPerson.getName() =="RandomString1");
}
//tests for :job
test attribute_job {
Person aPerson("RandomString1","RandomString1",123);
assertTrue( aPerson.setJob("RandomString1"));
assertTrue( aPerson.getJob() =="RandomString1");
assertTrue( aPerson.setJob("RandomString2"));
assertTrue( aPerson.getJob()=="RandomString2");
assertFalse( aPerson.getJob() =="RandomString1");
}
//tests for :id
test attribute_id {
Person aPerson("RandomString1","RandomString1",123);
assertTrue( aPerson.setId(123));
assertTrue( aPerson.getId() == 123);
assertTrue( aPerson.setId(321));
assertTrue( aPerson.getId() == 321);
assertFalse( aPerson.getId() == 123);
}
//------------------
//User-defined Tests
//------------------
test checkIfElse {
if(tempId == 1324){
assertTrue (job == "Saleman");
}
if else(tempId == 980){
asserTrue (job == "Cashier");
}
}
}
null
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.32.1.6535.66c005ced modeling language!*/
////---- Tests for GenericTestCase_association ----/////
test Calculator {
generate JUnit ;
depend Calculator,Number,Controller ;
GIVEN:
GenericTestCase_association.ump;
THEN:
//------------------
//User-defined Tests
//------------------
test checkifLogged_numbers {
Calculator c1 ( 4, 5) ;
String valueToCheck = p1.getNumbers();
Number tempNumber = numbers;
}
}
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.32.1.6535.66c005ced modeling language!*/
////---- Tests for GenericTestCase_association ----/////
test Number {
generate JUnit ;
depend Calculator,Number,Controller ;
GIVEN:
GenericTestCase_association.ump;
THEN:
}
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.32.1.6535.66c005ced modeling language!*/
////---- Tests for GenericTestCase_association ----/////
test Controller {
generate JUnit ;
depend Calculator,Number,Controller ;
GIVEN:
GenericTestCase_association.ump;
THEN:
}
null
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.32.1.6535.66c005ced modeling language!*/
////---- Tests for GenericTestCase_association_toSingular ----/////
test Calculator {
generate JUnit ;
depend Calculator,Number ;
GIVEN:
GenericTestCase_association_toSingular.ump;
THEN:
//------------------
//User-defined Tests
//------------------
test checkifLogged_numbers {
Calculator c1 ( 4, 5) ;
String valueToCheck = p1.getNumber();
Number tempNumber = number;
}
}
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.32.1.6535.66c005ced modeling language!*/
////---- Tests for GenericTestCase_association_toSingular ----/////
test Number {
generate JUnit ;
depend Calculator,Number ;
GIVEN:
GenericTestCase_association_toSingular.ump;
THEN:
}
null
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.32.1.6535.66c005ced modeling language!*/
////---- Tests for attribute ----/////
test A {
generate JUnit ;
depend A,B ;
GIVEN:
attribute.ump;
THEN:
//tests for :id
test attribute_id {
A aA("RandomString1",123,"unidentified","unidentified");
assertTrue( aA.setId("RandomString1"));
assertTrue( aA.getId() =="RandomString1");
assertTrue( aA.setId("RandomString2"));
assertTrue( aA.getId()=="RandomString2");
assertFalse( aA.getId() =="RandomString1");
}
//tests for :number
test attribute_number {
A aA("RandomString1",123,"unidentified","unidentified");
assertTrue( aA.setNumber(123));
assertTrue( aA.getNumber() == 123);
assertTrue( aA.setNumber(321));
assertTrue( aA.getNumber() == 321);
assertFalse( aA.getNumber() == 123);
}
//tests for :number2
test attribute_number2 {
A aA("RandomString1",123,"unidentified","unidentified");
assertTrue( aA.setNumber2(null));
assertTrue( aA.getNumber2() == null);
assertTrue( aA.setNumber2(null));
assertTrue( aA.getNumber2() == null);
assertFalse( aA.getNumber2() == null);
}
//tests for :number3
test attribute_number3 {
A aA("RandomString1",123,"unidentified","unidentified");
assertTrue( aA.setNumber3(123456789));
assertTrue( aA.getNumber3() == 123456789);
assertTrue( aA.setNumber3(987654321));
assertTrue( aA.getNumber3() == 987654321);
assertFalse( aA.getNumber3() == 123456789);
}
}
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.32.1.6535.66c005ced modeling language!*/
////---- Tests for attribute ----/////
test B {
generate JUnit ;
depend A,B ;
GIVEN:
attribute.ump;
THEN:
//tests for :name
test attribute_name {
B aB("RandomString1","RandomString1","RandomString1");
assertTrue( aB.setName("RandomString1"));
assertTrue( aB.getName() =="RandomString1");
assertTrue( aB.setName("RandomString2"));
assertTrue( aB.getName()=="RandomString2");
assertFalse( aB.getName() =="RandomString1");
}
//tests for :address
test attribute_address {
B aB("RandomString1","RandomString1","RandomString1");
assertTrue( aB.setAddress("RandomString1"));
assertTrue( aB.getAddress() =="RandomString1");
assertTrue( aB.setAddress("RandomString2"));
assertTrue( aB.getAddress()=="RandomString2");
assertFalse( aB.getAddress() =="RandomString1");
}
//tests for :id
test attribute_id {
B aB("RandomString1","RandomString1","RandomString1");
assertTrue( aB.setId("RandomString1"));
assertTrue( aB.getId() =="RandomString1");
assertTrue( aB.setId("RandomString2"));
assertTrue( aB.getId()=="RandomString2");
assertFalse( aB.getId() =="RandomString1");
}
}
null
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.32.1.6535.66c005ced modeling language!*/
////---- Tests for MixsetTest_SameTestMultipleMixsets ----/////
test Person {
generate JUnit ;
depend Person ;
GIVEN:
MixsetTest_SameTestMultipleMixsets.ump;
THEN:
//tests for :x
test attribute_x {
Person aPerson("RandomString1");
assertTrue( aPerson.setX("RandomString1"));
assertTrue( aPerson.getX() =="RandomString1");
assertTrue( aPerson.setX("RandomString2"));
assertTrue( aPerson.getX()=="RandomString2");
assertFalse( aPerson.getX() =="RandomString1");
}
//------------------
//User-defined Tests
//------------------
test checkName {
assertFalse(firstName == "Orlean");
assertTrue(firstName == "KingEdward");
assertFalse(firstName == "Orlean");
assertTrue(firstName == "KingEdward");
}
}
null
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.32.1.6535.66c005ced modeling language!*/
////---- Tests for ClassTemplateTest_CodeInjectionsParametersUnspecified ----/////
test Student {
generate JUnit ;
depend Student ;
GIVEN:
ClassTemplateTest_CodeInjectionsParametersUnspecified.ump;
THEN:
}
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.32.1.6535.66c005ced modeling language!*/
////---- Tests for ClassTemplateTest_Attributes ----/////
test Mentor {
generate JUnit ;
depend Mentor ;
GIVEN:
ClassTemplateTest_Attributes.ump;
THEN:
//tests for :MAX
test attribute_MAX {
}
//tests for :MIN
test attribute_MIN {
}
//tests for :HELLO
test attribute_HELLO {
}
//tests for :str
test attribute_immutable_str {
Mentor aMentor("RandomString1","Date.valueOf("1999-12-12")",123,"RandomString1");
//assertMethod(setStr());
assertTrue( aMentor.getStr() == null);
}
//tests for :str2
test attribute_lazy_immutable_str2 {
Mentor aMentor("RandomString1","Date.valueOf("1999-12-12")",123,"RandomString1");
//assertMethod(setStr2());
assertTrue( aMentor.getStr2() == null);
}
//tests for :someName
test attribute_lazy_someName {
Mentor aMentor("RandomString1","Date.valueOf("1999-12-12")",123,"RandomString1");
assertTrue (aMentor.getSomeName() == null );
assertTrue( aMentor.setSomeName("RandomString1"));
assertTrue( aMentor.getSomeName() =="RandomString1");
assertTrue( aMentor.setSomeName("RandomString2"));
assertTrue( aMentor.getSomeName()=="RandomString2");
assertFalse( aMentor.getSomeName() =="RandomString1");
}
//tests for :lDoub
test attribute_lazy_lDoub {
Mentor aMentor("RandomString1","Date.valueOf("1999-12-12")",123,"RandomString1");
assertTrue( aMentor.setLDoub(123456789));
assertTrue( aMentor.getLDoub() == 123456789);
assertTrue( aMentor.setLDoub(987654321));
assertTrue( aMentor.getLDoub() == 987654321);
assertFalse( aMentor.getLDoub() == 123456789);
}
//tests for :lBool
test attribute_lazy_lBool {
}
//tests for :name
test attribute_lazy_name {
Mentor aMentor("RandomString1","Date.valueOf("1999-12-12")",123,"RandomString1");
assertTrue (aMentor.getName() == null );
assertEqual(aMentor.getName(), "Johannes" );
assertTrue( aMentor.setName("RandomString1"));
assertTrue( aMentor.getName() =="RandomString1");
assertTrue( aMentor.setName("RandomString2"));
assertTrue( aMentor.getName()=="RandomString2");
assertFalse( aMentor.getName() =="RandomString1");
}
//tests for :d
test attribute_d {
Mentor aMentor("RandomString1","Date.valueOf("1999-12-12")",123,"RandomString1");
Date aDate = Date.valueOf("1999-12-12");
assertTrue( aMentor.setD(aDate));
assertEqual( aMentor.getD() , aDate);
}
//tests for :t
test attribute_t {
Mentor aMentor("RandomString1","Date.valueOf("1999-12-12")",123,"RandomString1");
Time sTime = Time.valueOf(new Time());
assertEqual(aMentor.getT(), sTime );
Time aTime = Time.valueOf("12:59:59");
assertTrue( aMentor.setT(aTime));
assertEqual( aMentor.getT() , aTime);
}
//tests for :i
test attribute_i {
Mentor aMentor("RandomString1","Date.valueOf("1999-12-12")",123,"RandomString1");
assertTrue( aMentor.setI(123));
assertTrue( aMentor.getI() == 123);
assertTrue( aMentor.setI(321));
assertTrue( aMentor.getI() == 321);
assertFalse( aMentor.getI() == 123);
}
//tests for :derivedTwiceI
test attribute_derivedTwiceI {
Mentor aMentor("RandomString1","Date.valueOf("1999-12-12")",123,"RandomString1");
assertEqual(aMentor.getDerivedTwiceI(), i*2 );
assertTrue( aMentor.setDerivedTwiceI(123));
assertTrue( aMentor.getDerivedTwiceI() == 123);
assertTrue( aMentor.setDerivedTwiceI(321));
assertTrue( aMentor.getDerivedTwiceI() == 321);
assertFalse( aMentor.getDerivedTwiceI() == 123);
}
//tests for :x
test attribute_x {
Mentor aMentor("RandomString1","Date.valueOf("1999-12-12")",123,"RandomString1");
assertTrue( aMentor.setX(123));
assertTrue( aMentor.getX() == 123);
assertTrue( aMentor.setX(321));
assertTrue( aMentor.getX() == 321);
assertFalse( aMentor.getX() == 123);
}
//tests for :id
test attribute_id {
Mentor aMentor("RandomString1","Date.valueOf("1999-12-12")",123,"RandomString1");
assertTrue( aMentor.setId("RandomString1"));
assertTrue( aMentor.getId() =="RandomString1");
assertTrue( aMentor.setId("RandomString2"));
assertTrue( aMentor.getId()=="RandomString2");
assertFalse( aMentor.getId() =="RandomString1");
}
//tests for :p
test attribute_defaulted_p {
Mentor aMentor("RandomString1","Date.valueOf("1999-12-12")",123,"RandomString1");
assertEqual(aMentor.getP(), "robot" );
assertTrue( aMentor.setP("RandomString1"));
assertTrue( aMentor.getP() =="RandomString1");
assertTrue( aMentor.setP("RandomString2"));
assertTrue( aMentor.getP()=="RandomString2");
assertFalse( aMentor.getP() =="RandomString1");
assertTrue(aMentor.resetP());
assertEqual( aMentor.getDefaultP(), "robot" );
}
//tests for :q
test attribute_q {
Mentor aMentor("RandomString1","Date.valueOf("1999-12-12")",123,"RandomString1");
assertEqual(aMentor.getQ(), "chicken" );
assertTrue( aMentor.setQ("RandomString1"));
assertTrue( aMentor.getQ() =="RandomString1");
assertTrue( aMentor.setQ("RandomString2"));
assertTrue( aMentor.getQ()=="RandomString2");
assertFalse( aMentor.getQ() =="RandomString1");
}
//tests for :r
test attribute_defaulted_r {
Mentor aMentor("RandomString1","Date.valueOf("1999-12-12")",123,"RandomString1");
assertEqual(aMentor.getR(), "" );
assertTrue( aMentor.setR("RandomString1"));
assertTrue( aMentor.getR() =="RandomString1");
assertTrue( aMentor.setR("RandomString2"));
assertTrue( aMentor.getR()=="RandomString2");
assertFalse( aMentor.getR() =="RandomString1");
assertTrue(aMentor.resetR());
assertEqual( aMentor.getDefaultR(), "" );
}
//tests for :s
test attribute_immutable_s {
Mentor aMentor("RandomString1","Date.valueOf("1999-12-12")",123,"RandomString1");
//assertMethod(setS());
assertTrue( aMentor.getS() == "123");
}
//tests for :tt
test attribute_tt {
Mentor aMentor("RandomString1","Date.valueOf("1999-12-12")",123,"RandomString1");
Date sDate = Date.valueOf("1978-12-25");
assertEqual(aMentor.getTt(), sDate );
Date aDate = Date.valueOf("1999-12-12");
assertTrue( aMentor.setTt(aDate));
assertEqual( aMentor.getTt() , aDate);
}
//tests for :u
test attribute_u {
Mentor aMentor("RandomString1","Date.valueOf("1999-12-12")",123,"RandomString1");
Time sTime = Time.valueOf("12:13:14");
assertEqual(aMentor.getU(), sTime );
Time aTime = Time.valueOf("12:59:59");
assertTrue( aMentor.setU(aTime));
assertEqual( aMentor.getU() , aTime);
}
//tests for :v
test attribute_defaulted_v {
Mentor aMentor("RandomString1","Date.valueOf("1999-12-12")",123,"RandomString1");
Date sDate = Date.valueOf("1978-12-26");
assertEqual(aMentor.getV(), sDate );
Date aDate = Date.valueOf("1999-12-12");
assertTrue( aMentor.setV(aDate));
assertEqual( aMentor.getV() , aDate);
assertTrue(aMentor.resetV());
Date resetDate = Date.valueOf("1978-12-26");
assertEqual( aMentor.getDefaultV(), resetDate);
}
//tests for :w
test attribute_defaulted_w {
Mentor aMentor("RandomString1","Date.valueOf("1999-12-12")",123,"RandomString1");
Time sTime = Time.valueOf("12:59:59");
assertEqual(aMentor.getW(), sTime );
Time aTime = Time.valueOf("12:59:59");
assertTrue( aMentor.setW(aTime));
assertEqual( aMentor.getW() , aTime);
assertTrue(aMentor.resetW());
Time resetTime = Time.valueOf("12:59:59");
assertEqual( aMentor.getDefaultW(), resetTime);
}
}
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.32.1.6535.66c005ced modeling language!*/
/*
This is a student
*/
////---- Tests for ClassTemplateTest_Comment ----/////
test Student {
generate JUnit ;
depend Student ;
GIVEN:
ClassTemplateTest_Comment.ump;
THEN:
}
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.32.1.6535.66c005ced modeling language!*/
////---- Tests for AssociationMultilineComment ----/////
test Foo {
generate JUnit ;
depend Foo,Bar ;
GIVEN:
AssociationMultilineComment.ump;
THEN:
}
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.32.1.6535.66c005ced modeling language!*/
////---- Tests for ClassTemplateTest_EmptyStringAttr ----/////
test Student {
generate JUnit ;
depend Student ;
GIVEN:
ClassTemplateTest_EmptyStringAttr.ump;
THEN:
//tests for :grade
test attribute_grade {
Student aStudent();
assertEqual(aStudent.getGrade(), "" );
assertTrue( aStudent.setGrade("RandomString1"));
assertTrue( aStudent.getGrade() =="RandomString1");
assertTrue( aStudent.setGrade("RandomString2"));
assertTrue( aStudent.getGrade()=="RandomString2");
assertFalse( aStudent.getGrade() =="RandomString1");
}
}
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.32.1.6535.66c005ced modeling language!*/
////---- Tests for ClassTemplateTest_AssociationAttributes ----/////
test Token {
generate JUnit ;
depend Token,Position ;
GIVEN:
ClassTemplateTest_AssociationAttributes.ump;
THEN:
//tests for :p
test attribute_p {
}
}
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.32.1.6535.66c005ced modeling language!*/
/*
This is a student
Multiple comments
on several lines
*/
////---- Tests for ClassTemplateTest_MultiComment ----/////
test Student {
generate JUnit ;
depend Student ;
GIVEN:
ClassTemplateTest_MultiComment.ump;
THEN:
}
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.32.1.6535.66c005ced modeling language!*/
/*
* I am a class comment.
*
* Notice how there are 4 empty lines below me.
*
*
*
*
* And 2 below me.
*
*
* These lines should come out as we see here.
* Comments such as these are often used to improve readability through whitespace clarity.
*/
////---- Tests for ClassCommentWithEmptyLines ----/////
test Foo {
generate JUnit ;
depend Foo ;
GIVEN:
ClassCommentWithEmptyLines.ump;
THEN:
}
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.32.1.6535.66c005ced modeling language!*/
////---- Tests for AttributeMultilineComment ----/////
test Foo {
generate JUnit ;
depend Foo ;
GIVEN:
AttributeMultilineComment.ump;
THEN:
//tests for :name
test attribute_name {
Foo aFoo("RandomString1");
assertTrue( aFoo.setName("RandomString1"));
assertTrue( aFoo.getName() =="RandomString1");
assertTrue( aFoo.setName("RandomString2"));
assertTrue( aFoo.getName()=="RandomString2");
assertFalse( aFoo.getName() =="RandomString1");
}
}
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.32.1.6535.66c005ced modeling language!*/
////---- Tests for ClassTemplateTest_NoNamespace ----/////
test Token {
generate JUnit ;
depend Token ;
GIVEN:
ClassTemplateTest_NoNamespace.ump;
THEN:
}
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.32.1.6535.66c005ced modeling language!*/
////---- Tests for MultipleAttributeComments ----/////
test Foo {
generate JUnit ;
depend Foo ;
GIVEN:
MultipleAttributeComments.ump;
THEN:
//tests for :testAttribute1
test attribute_testAttribute1 {
Foo aFoo("RandomString1","RandomString1","RandomString1","RandomString1");
assertTrue( aFoo.setTestAttribute1("RandomString1"));
assertTrue( aFoo.getTestAttribute1() =="RandomString1");
assertTrue( aFoo.setTestAttribute1("RandomString2"));
assertTrue( aFoo.getTestAttribute1()=="RandomString2");
assertFalse( aFoo.getTestAttribute1() =="RandomString1");
}
//tests for :testAttribute2
test attribute_testAttribute2 {
Foo aFoo("RandomString1","RandomString1","RandomString1","RandomString1");
assertTrue( aFoo.setTestAttribute2("RandomString1"));
assertTrue( aFoo.getTestAttribute2() =="RandomString1");
assertTrue( aFoo.setTestAttribute2("RandomString2"));
assertTrue( aFoo.getTestAttribute2()=="RandomString2");
assertFalse( aFoo.getTestAttribute2() =="RandomString1");
}
//tests for :testAttribute3
test attribute_testAttribute3 {
Foo aFoo("RandomString1","RandomString1","RandomString1","RandomString1");
assertTrue( aFoo.setTestAttribute3("RandomString1"));
assertTrue( aFoo.getTestAttribute3() =="RandomString1");
assertTrue( aFoo.setTestAttribute3("RandomString2"));
assertTrue( aFoo.getTestAttribute3()=="RandomString2");
assertFalse( aFoo.getTestAttribute3() =="RandomString1");
}
//tests for :testAttribute4
test attribute_testAttribute4 {
Foo aFoo("RandomString1","RandomString1","RandomString1","RandomString1");
assertTrue( aFoo.setTestAttribute4("RandomString1"));
assertTrue( aFoo.getTestAttribute4() =="RandomString1");
assertTrue( aFoo.setTestAttribute4("RandomString2"));
assertTrue( aFoo.getTestAttribute4()=="RandomString2");
assertFalse( aFoo.getTestAttribute4() =="RandomString1");
}
}
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.32.1.6535.66c005ced modeling language!*/
////---- Tests for ClassTemplateTest_CodeInjectionsComments ----/////
test Student {
generate JUnit ;
depend Student ;
GIVEN:
ClassTemplateTest_CodeInjectionsComments.ump;
THEN:
}
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.32.1.6535.66c005ced modeling language!*/
////---- Tests for ClassTemplateTest_IsA ----/////
test SubMentor {
generate JUnit ;
depend Mentor,SubMentor,SubMentor2 ;
GIVEN:
ClassTemplateTest_IsA.ump;
THEN:
}
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.32.1.6535.66c005ced modeling language!*/
////---- Tests for ClassTemplateTest_IsA ----/////
test SubMentor2 {
generate JUnit ;
depend Mentor,SubMentor,SubMentor2 ;
GIVEN:
ClassTemplateTest_IsA.ump;
THEN:
//tests for :subName
test attribute_subName {
SubMentor2 aSubMentor2("RandomString1");
assertTrue( aSubMentor2.setSubName("RandomString1"));
assertTrue( aSubMentor2.getSubName() =="RandomString1");
assertTrue( aSubMentor2.setSubName("RandomString2"));
assertTrue( aSubMentor2.getSubName()=="RandomString2");
assertFalse( aSubMentor2.getSubName() =="RandomString1");
}
}
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.32.1.6535.66c005ced modeling language!*/
////---- Tests for ClassTemplateTest_ListAttributes ----/////
test Token {
generate JUnit ;
depend Token,Position ;
GIVEN:
ClassTemplateTest_ListAttributes.ump;
THEN:
//tests for :positions
test attribute_positions {
}
}
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.32.1.6535.66c005ced modeling language!*/
////---- Tests for ClassTemplateTest_CodeInjectionsBasic ----/////
test Student {
generate JUnit ;
depend Student ;
GIVEN:
ClassTemplateTest_CodeInjectionsBasic.ump;
THEN:
}
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.32.1.6535.66c005ced modeling language!*/
////---- Tests for ClassTemplateTest_CodeInjectionsParametersMulti ----/////
test Student {
generate JUnit ;
depend Student ;
GIVEN:
ClassTemplateTest_CodeInjectionsParametersMulti.ump;
THEN:
}
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.32.1.6535.66c005ced modeling language!*/
////---- Tests for ClassTemplateTest_CodeInjectionsNoBraces ----/////
test Student {
generate JUnit ;
depend Student ;
GIVEN:
ClassTemplateTest_CodeInjectionsNoBraces.ump;
THEN:
}
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.32.1.6535.66c005ced modeling language!*/
////---- Tests for MethodCommentWithEmptyLines ----/////
test Foo {
generate JUnit ;
depend Foo ;
GIVEN:
MethodCommentWithEmptyLines.ump;
THEN:
}
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.32.1.6535.66c005ced modeling language!*/
////---- Tests for ClassTemplateTest_EmptyClass ----/////
test Mentor {
generate JUnit ;
depend Mentor ;
GIVEN:
ClassTemplateTest_EmptyClass.ump;
THEN:
}
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.32.1.6535.66c005ced modeling language!*/
////---- Tests for ClassTemplateTest_CodeInjectionsSingleLine ----/////
test Student {
generate JUnit ;
depend Student ;
GIVEN:
ClassTemplateTest_CodeInjectionsSingleLine.ump;
THEN:
}
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.32.1.6535.66c005ced modeling language!*/
/*
This is a student
Multiple comments
on several lines
*/
////---- Tests for ClassTemplateTest_MultiLineComment ----/////
test Student {
generate JUnit ;
depend Student ;
GIVEN:
ClassTemplateTest_MultiLineComment.ump;
THEN:
}
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.32.1.6535.66c005ced modeling language!*/
////---- Tests for AssociationInlineComment ----/////
test Foo {
generate JUnit ;
depend Foo,Bar ;
GIVEN:
AssociationInlineComment.ump;
THEN:
}
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.32.1.6535.66c005ced modeling language!*/
/*
This is a student
*/
////---- Tests for ClassTemplateTest_GarbageComment ----/////
test Student {
generate JUnit ;
depend Student ;
GIVEN:
ClassTemplateTest_GarbageComment.ump;
THEN:
}
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.32.1.6535.66c005ced modeling language!*/
////---- Tests for MultipleMethodComments ----/////
test Foo {
generate JUnit ;
depend Foo ;
GIVEN:
MultipleMethodComments.ump;
THEN:
}
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.32.1.6535.66c005ced modeling language!*/
////---- Tests for MultipleAssociationComments ----/////
test Foo {
generate JUnit ;
depend Foo,Bar1,Bar2,Bar3,Bar4 ;
GIVEN:
MultipleAssociationComments.ump;
THEN:
}
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.32.1.6535.66c005ced modeling language!*/
////---- Tests for MethodInlineComment ----/////
test Foo {
generate JUnit ;
depend Foo ;
GIVEN:
MethodInlineComment.ump;
THEN:
}
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.32.1.6535.66c005ced modeling language!*/
////---- Tests for MethodMultilineComment ----/////
test Foo {
generate JUnit ;
depend Foo ;
GIVEN:
MethodMultilineComment.ump;
THEN:
}
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.32.1.6535.66c005ced modeling language!*/
////---- Tests for AttributeInlineComment ----/////
test Foo {
generate JUnit ;
depend Foo ;
GIVEN:
AttributeInlineComment.ump;
THEN:
//tests for :bar
test attribute_bar {
Foo aFoo("RandomString1");
assertTrue( aFoo.setBar("RandomString1"));
assertTrue( aFoo.getBar() =="RandomString1");
assertTrue( aFoo.setBar("RandomString2"));
assertTrue( aFoo.getBar()=="RandomString2");
assertFalse( aFoo.getBar() =="RandomString1");
}
}
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.32.1.6535.66c005ced modeling language!*/
////---- Tests for ClassTemplateTest_Depend ----/////
test Mentor {
generate JUnit ;
depend Mentor ;
GIVEN:
ClassTemplateTest_Depend.ump;
THEN:
}