Developing Advanced Eclipse XMF Applications

case LibraryTest {

  // Define system states that will be used in the 
  // test scripts....

  state hasBook(n)->(b) {
  
    // State hasBook is satisfied when the
    // current library state contains a book
    // b with the title n. The state receives
    // the name n and returns the book b...
    
    obj(root,library.Library) {
      books contains b;    
    }
    
    obj(b,library.Book) {
      title = n;
    }
  }  

  ->
  
  let () = match hasBook("Pride and Prejudice")
  in 
      // If there is a book with the supplied title then 
      // raise an error...
      
      raise bookExists("Not expecting a book.");

  else {
    // Do nothing...
  }
}

obj(var,class) {
  slotName = slotValue;
  slotName contains slotValue;
  ...
}

case LibraryTest {

  // Define system states that will be used in the 
  // test scripts....

  state hasBook(n)->(b) {
  
    // State hasBook is satisfied when the
    // current library state contains a book
    // b with the title n. The state receives
    // the name n and returns the book b...
    
    obj(root,library.Library) {
      books contains b;    
    }
    
    obj(b,library.Book) {
      title = n;
    }
  }  
  
  state hasCopy(book,id) -> (copy) {
  
    // State hasCopy is satisfied when the
    // current library state has a book with
    // the supplied id. the state returns the
    // copy...
    
    obj(root,library.Library) {
      books contains book;
      copies contains copy;
    }
    
    obj(copy,library.Copy) {
      id = id;
      book = book;
    }
  }  
  
  state hasReader(name) -> (reader) {
  
    // State hasReader is satisfied when the
    // current library state has a reader with
    // the supplied name. The reader is
    // returned...
    
    obj(root,library.Library) {
      readers contains reader;
    }
    
    obj(reader,library.Reader) {
      name = name;
    }
  } 
  
  state borrows(reader,copy) -> () {
  
    // State borrows is satisfied when the
    // current library state records a borrowing
    // event between the supplied reader and the
    // supplied book copy. Nothing is returned...
    
    obj(root,library.Library) {
      borrowings contains b;
    }
    
    obj(b,library.Borrows) {
      reader = reader;
      copy = copy;
    }
  }   
   
  ->
  
  // The following test script is perfomed with respect
  // to the declared system states above...
  
  // Firstly, check that there is no book in the
  // library with the supplied title...
  
  let () = match hasBook("Pride and Prejudice")
  in 
      // If there is a book with the supplied title then 
      // raise an error...
      
      raise bookExists("Not expecting a book.");
  else {
  
    // Perform the system action that adds a book
    // with the given title...
    
    do addBook("Pride and Prejudice");
    
    // Now use the same state check to ensure that
    // the library state has been updated correctly...
    
    let (book) = match hasBook("Pride and Prejudice")
    in {
    
      // If we get here then the library is OK.
      // Now add a copy of the book...
      
      do addCopy("Pride and Prejudice","copy1");
      
      // Check that the library has recorded the copy...
      
      let (copy) = match hasCopy(book,"copy1")
      in {
      
        // If we get here then the library has correctly
        // recorded the copy of the book. Now add a reader
        // with the given name...
        
        do addReader("fred");
        
        // Check that the reader was added...
        
        let (reader) = match hasReader("fred")
        in {
        
          // If we get here then the library has a copy of
          // the book and the reader is registered. Record
          // the reader borrowing the book from the library...
          
          do borrow("fred","copy1");
          
          // Check that the borrowing has taken place...
          
          let () = match borrows(reader,copy)
          in {
          
            // If we get here then everything has gone OK and
            // we do nothing...
          }
          
          // The borrowing event was not recorded...
          
          else raise noBorrow("fred","copy1");
        }
        
        // The reader was not registered...
        
        else raise readerNotCreated("fred");
      }
      
      // A copy of the book was not recorded...
      
      else raise noCopy("copy1");
    }
    
    // No book was added to the library...
    
    else raise noBook("Pride and Prejudice.");
  }
}

@Service newTestSuite(testModel)
  let name = xmf.getString("Name","Name of new Test Suite","")
  in testModel.testSuites.add(TestSuite(name))
  end
end;

@Service loadTestCase(testSuite)
 
  // Use a try to catch any parsing errors that
  // might be raised and then use a dialog to report
  // the error...

  try 
    testSuite.loadTestCase(xmf.openFile(".","*.txt",""))
  catch(x)
    xmf.reportError(x.message)
  end
end;

@Service perform(testCase,library)
  testCase.perform(library)
end;

@Service report(report)
  xmf.browser("Report",report.report())
end;
 

   <extension point="org.eclipse.ui.popupMenus">
     <objectContribution id="id" objectClass="testing.TestModel">
       <action id="newTestSuite" label="New Test Suite" menubarPath="additions" class="actions.HandleAction" enablesFor="1">
       </action>
     </objectContribution>
   </extension> 

   <extension point="org.eclipse.ui.popupMenus">
     <objectContribution id="id" objectClass="testing.TestSuite">
       <action id="loadTestCase" label="Load Test Case" menubarPath="additions" class="actions.HandleAction" enablesFor="1">
       </action>
     </objectContribution>
   </extension> 
  
   <extension point="org.eclipse.ui.popupMenus">
     <objectContribution id="id" objectClass="testing.TestCase">
       <action id="perform" label="Perform" menubarPath="additions" class="actions.HandleAction" enablesFor="1">
       </action>
     </objectContribution>
   </extension> 
  
   <extension point="org.eclipse.ui.popupMenus">
     <objectContribution id="id" objectClass="reports.Report">
       <action id="report" label="Report" menubarPath="additions" class="actions.HandleAction" enablesFor="1">
       </action>
     </objectContribution>
   </extension>
 

public void run(IAction action) {
	  
  XMFMachine machine = XMFMachineRegistry.getMachine("testing.machine");

  String id = action.getId();
  Object o = selection.getFirstElement();
  ClassLoader loader = classLoader();

  if (id.equals("newTestSuite"))
    machine.sendService("newTestSuite", new Object[] { o },loader);

  else if (id.equals("loadTestCase")) 
    machine.sendService("loadTestCase", new Object[] { o },loader);

  else if (id.equals("perform")) {
    Library library = LibraryFactoryImpl.eINSTANCE.createLibrary();
    machine.sendService("perform", new Object[] { o, library },loader);
 
  } else if (id.equals("report"))
    machine.sendService("report", new Object[] { o },loader);

  else System.out.println("Unknown action id: " + id);
}
 

context TestSuite
  @Operation loadTestCase(path:String)
 
    // Use the Grammar::parseFile operation to parse the contents
    // of the file, starting at the non-terminal TestCase...
 
    self.getTestCases().add(TestCase.grammar.parseFile(path,"TestCase",Seq{}))
  end

@Grammar extends State.grammar
    
      TestCase ::= 
      
        // A test case is named...
      
        'case' n = Name '{'
        
           // has a sequence of state patterns...
           
           S = State* 
           '->'
           
           // a test script action...
            
           a = Action 
        '}' 
        
      {   // Create the test script...
      
          let t = TestCase(n,a) 
          in 
             // Add the states into the script...
             
             @For s in S do
               t.getStates().add(s)
             end;
             t
          end
      }.
      
      Action ::= 
      
        // An action is one of...
        
        Do        // Call an SUT function...
      | Block     // Perform a sequence of actions...
      | Let       // Bind some variables...
      | Raise.    // Raise an exception.
      
      Condition ::= Str.
      
      Do ::= 
        
        // Perform a named SUT function...
        
        'do' n = Name A = LetArgs ';' { 
        
        // Create the Do...
        
        let d = Do(n)
        in 
           // Add in the argument values...
           
           @For a in A do
             d.getArgs().add(a)
           end;
           d
        end
      }.
      
      Block ::= 
      
        // A block is a sequence of actions...
      
        '{' as = Action* '}' 
        
        // Create the block an add in the actions...
        
         { let b = Block() 
           in @For a in as do 
                b.getActions().add(a) 
              end; 
              b 
           end 
      }.
      
      Let ::= 
      
        // All types of let-action bind 0 or more
        // arguments. the let-actions differ in terms
        // of where the variable values some from...
      
        'let' V = LetVars '=' LetBind^(V).
      
      LetBind(V) ::= 
      
        // Either a state match or an SUT function...
        
        MatchingLet^(V)
      | DoingLet^(V).
      
      MatchingLet(V) ::= 
      
        // Name the state pattern and supply any input
        // values..
      
        'match' 
        
          n = Name 
          
          A = LetArgs 
          
        // Specify the action to perform when the
        // match is successful...
        
        'in' a = Action 
        
        // Specify the action to perform when the
        // match fails...  
          
        'else' b = Action 
        
      {
        // Create the matching-let and populate the
        // apropriate parts...
        
        let l = MatchingLet(n,a,b)
        in @For v in V do
             l.getBindings().add(v)
           end;
           @For a in A do
             l.getArgs().add(a)
           end;
           l
        end
      }.
      
      DoingLet(V) ::= 
      
        // Name the SUT function and supply the values...
      
        'do' n = Name A = LetArgs 
        
        // Perform a body for the variables...
        
        'in' a = Action {
        
        // Create the let and populate it...
        
        let l = DoingLet(n,a)
        in @For v in V do
             l.getBindings().add(v)
           end;
           @For a in A do
             l.getArgs().add(a)
           end;
           l
        end
      }.
      
      LetVars ::= '(' LetVarsTail.
      
      LetVarsTail ::=
        n = Name ns = (',' Name)* ')' { Seq{n|ns}->collect(n | LetVar(n)) }
      | ')' { Seq{} }.
      
      LetArgs ::= '(' LetArgsTail.
      
      LetArgsTail ::=
        a = LetArg as = (',' LetArg)* ')' { Seq{a|as} }
      | ')' { Seq{} }.
      
      LetArg ::= LetVarRef | LetConst.
      
      LetVarRef ::= n = Name { LetVarRef(n) }.
      
      LetConst ::= LetInt | LetStr.
      
      LetInt ::= i = Int { LetInt(i) }.
      
      LetStr ::= s = Str { LetStr(s) }.
      
      Raise ::= 'raise' n = Name A = LetArgs ';' {
        let r = Raise(n)
        in @For a in A do
             r.getArgs().add(a)
           end;
           r
        end
      }.
      
    end

@Operation perform(state)
 
   // This is the entry point from the service...
 
   self.perform(Seq{},state)
end
    
@Operation perform(env,state)
 
  // Supplied with the variable environment and the SUT
  // state. Create a new report, create a state environment
  // then call the root action with the arguments...
 
  let report = Report(name,Date())
  in self.getReports().add(report);
     action.perform(env,self.stateEnv(),state,report,
       @Operation(varEnv,state)
          varEnv
        end)
  end
end
    
@Operation stateEnv()
 
  // Calculate a state environment...
 
  states.asSeq()->iterate(s e = Seq{} | e.bind(s.getName(),s))
end