import com.ericsson.otp.erlang.OtpErlangObject; //导入依赖的package包/类
@Test
public void testParseBig()
{
	final String text = "{\'this is an atom\',\"this is a string\",[[-234],{}]}";
	OtpErlangObject obtained = ErlangLabel.parseText(text);
	checkResponse(runner, text, text);
	Assert.assertEquals(new OtpErlangTuple(new OtpErlangObject[]{
					new OtpErlangAtom("this is an atom"),
					new OtpErlangString("this is a string"),
					new OtpErlangList(new OtpErlangObject[]{
							new OtpErlangList(new OtpErlangObject[]{
									new OtpErlangInt(-234)
							}),
							new OtpErlangTuple(new OtpErlangObject[]{
							})
					})
			}),obtained);
}
 

import com.ericsson.otp.erlang.OtpErlangObject; //导入依赖的package包/类
/** This one has to be called after construction of the runner. */
public void initRunner()
{
	// Now create another genserver to handle requests from this runner. Upon failure, the box remains closed.
	try
	{
		mboxOpen = true;
		call(new OtpErlangObject[] { new OtpErlangAtom("startrunner"), new OtpErlangAtom(getRunnerName()) }, "Failed to start a new runner.");
		genServerToCall = getRunnerName();
	}
	catch(IllegalArgumentException ex)
	{// if anything fails, eliminate this runner
		close();
		throw(ex);// rethrow
	}
}
 

import com.ericsson.otp.erlang.OtpErlangObject; //导入依赖的package包/类
/** Closes the mailbox, causing the linked processes to receive an exception. */
public synchronized void close()
{
	synchronized(nameToRunnerMap)
	{
		if (mboxOpen && !genServerToCall.equals(genServerDefault))
			try
			{
				call(new OtpErlangObject[] { new OtpErlangAtom("terminate") }, 1000);// a short timeout here since we do not care whether we are successful. Dormant processes are not too bad; timeouts on closing mboxes are possibly worse if we are closing many inboxes following unexpected termination of Erlang runtime. 
			}
			catch(IllegalArgumentException ex)
			{// if anything fails, ignore this
			}
		nameToRunnerMap.remove(this);
		thisMbox.close();
		mboxOpen = false;
	}
}
 

import com.ericsson.otp.erlang.OtpErlangObject; //导入依赖的package包/类
/** A bigger structure to dump. */
@Test
public void testToString12()
{
	Assert.assertEquals("{\'this is an atom\',\"this is a string\",[[-234],{}]}",
			ErlangLabel.dumpErlangObject(new OtpErlangTuple(new OtpErlangObject[]{
					new OtpErlangAtom("this is an atom"),
					new OtpErlangString("this is a string"),
					new OtpErlangList(new OtpErlangObject[]{
							new OtpErlangList(new OtpErlangObject[]{
									new OtpErlangInt(-234)
							}),
							new OtpErlangTuple(new OtpErlangObject[]{
							})
					})
			})));
}
 

import com.ericsson.otp.erlang.OtpErlangObject; //导入依赖的package包/类
/** Special case of fsmdiff - disconnected states with different names */
@Test
public void testFsmDiff3a()
{
	Configuration config = Configuration.getDefaultConfiguration().copy();config.setGdFailOnDuplicateNames(false);
	LearnerGraphND grA = new LearnerGraphND(config);
	OtpErlangObject grAerlang = ErlangLabel.parseText("{statemachine,['P1000','P1002','N1000'],"+
            "[{'P1000','a','P1000'}],"+
            "'P1000',"+
            "['a']}");
	Synapse.StatechumProcess.parseStatemachine(grAerlang,grA,null,true);

	LearnerGraphND grB = new LearnerGraphND(config);
	Synapse.StatechumProcess.parseStatemachine(ErlangLabel.parseText("{statemachine,['P1000','P1001','N1001'],"+
             "[{'P1000','a','P1001'}],"+
             "'P1000',"+
             "['a']}"),grB,null,true);
	
	OtpErlangObject difference = DifferenceVisualiser.ChangesToGraph.computeGD(grA, grB, config);
	Assert.assertEquals("{'statemachinedifference',[{'P1000','a','P1001'}],[{'P1000','a','P1000'}],['N1001','P1001'],['N1000','P1002'],[],'P1000'}",ErlangLabel.dumpErlangObject(difference));

	LearnerGraphND shouldBeLikePrevious = new LearnerGraphND(grA,config);
	DifferenceVisualiser.ChangesToGraph.load(difference).applyDiff(shouldBeLikePrevious, config);
	DifferentFSMException ex = WMethod.checkM(grB, shouldBeLikePrevious);
	Assert.assertNull(ex);Assert.assertEquals(grB.getStateNumber(),shouldBeLikePrevious.getStateNumber());
}
 

import com.ericsson.otp.erlang.OtpErlangObject; //导入依赖的package包/类
@Test
public void testSetRed3()
{
	Configuration config = Configuration.getDefaultConfiguration().copy();config.setGdFailOnDuplicateNames(false);
	final LearnerGraphND grA = new LearnerGraphND(config);
	OtpErlangObject grAerlang = ErlangLabel.parseText("{statemachine,['P1000','P1002','N1000'],"+
            "[{'P1000',a,'P1000'},"+
            " {'P1000',b,'P1002'},"+
            " {'P1000',c,'N1000'},"+
            " {'P1002',c,'P1002'},"+
            " {'P1002',d,'P1002'}],"+
            "'P1000',"+
            "[d,b,c,a]}");
	Synapse.StatechumProcess.parseStatemachine(grAerlang,grA,null,true);
	Assert.assertEquals(0, grA.getRedStateNumber());
	checkForCorrectException(new whatToRun() { public @Override void run() {
		Synapse.StatechumProcess.setReds(new OtpErlangList(new OtpErlangObject[]{new OtpErlangString("P1002")}), grA);
	}},ClassCastException.class,"OtpErlangString");
}
 

import com.ericsson.otp.erlang.OtpErlangObject; //导入依赖的package包/类
/**
 * Extracts dependencies of the supplied module, assuming the module has
 * been successfully compiled and .beam file exists.
 * 
 * @param file
 *            the file of the module
 * @throws IOException
 *             if this fails.
 */
public void loadDependencies(File file, Configuration config) {
	OtpErlangTuple response = ErlangRunner.getRunner(config.getErlangMboxName()).call(
			new OtpErlangObject[] { new OtpErlangAtom("dependencies"),
					new OtpErlangAtom(ErlangRunner.getName(file, ErlangRunner.ERL.BEAM, config.getErlangCompileIntoBeamDirectory())) },
			"Could not load dependencies of " + file.getName());
	
	// the first element is 'ok'
	OtpErlangList listOfDepTuples = (OtpErlangList) response.elementAt(1);
	for (OtpErlangObject tup : listOfDepTuples.elements()) {
		String mod = ((OtpErlangAtom) ((OtpErlangTuple) tup).elementAt(0)).atomValue();
		if (!stdModsList.contains(mod) && !dependencies.contains(mod)) {
			dependencies.add(mod);
		}
	}
}
 

import com.ericsson.otp.erlang.OtpErlangObject; //导入依赖的package包/类
/** Special case of fsmdiff - disconnected states */
@Test
public void testFsmDiff5()
{
	Configuration config = Configuration.getDefaultConfiguration().copy();config.setGdFailOnDuplicateNames(false);
	LearnerGraphND grA = new LearnerGraphND(config);
	OtpErlangObject grAerlang = ErlangLabel.parseText("{statemachine,['P1000','P1002','N1000'],"+
            "[{'P1000','a','P1000'}],"+
            "'P1000',"+
            "['a']}");
	Synapse.StatechumProcess.parseStatemachine(grAerlang,grA,null,true);

	LearnerGraphND grB = new LearnerGraphND(config);
	Synapse.StatechumProcess.parseStatemachine(ErlangLabel.parseText("{statemachine,['P1000','P1001'],"+
             "[{'P1000','a','P1001'}],"+
             "'P1000',"+
             "['a']}"),grB,null,true);
	
	OtpErlangObject difference = DifferenceVisualiser.ChangesToGraph.computeGD(grA, grB, config);
	Assert.assertEquals("{'statemachinedifference',[{'P1000','a','P1001'}],[{'P1000','a','P1000'}],['P1001'],['N1000','P1002'],[],'P1000'}",ErlangLabel.dumpErlangObject(difference));

	LearnerGraphND shouldBeLikePrevious = new LearnerGraphND(grA,config);
	DifferenceVisualiser.ChangesToGraph.load(difference).applyDiff(shouldBeLikePrevious, config);
	DifferentFSMException ex = WMethod.checkM(grB, shouldBeLikePrevious);
	Assert.assertNull(ex);Assert.assertEquals(grB.getStateNumber(),shouldBeLikePrevious.getStateNumber());
}
 

import com.ericsson.otp.erlang.OtpErlangObject; //导入依赖的package包/类
/** Turns the supplied graph into an Erlang tuple. 
 * @param gr graph to convert. 
 */
public static <TARGET_TYPE,CACHE_TYPE extends CachedData<TARGET_TYPE,CACHE_TYPE>> OtpErlangTuple constructFSM(AbstractLearnerGraph<TARGET_TYPE,CACHE_TYPE> gr)
{
	List<OtpErlangObject> statesList = new LinkedList<OtpErlangObject>(), transitions = new LinkedList<OtpErlangObject>();
	Map<String,OtpErlangObject> alphabet = new TreeMap<String,OtpErlangObject>();
	
	for(Entry<CmpVertex,Map<Label,TARGET_TYPE>> entry:gr.transitionMatrix.entrySet()) 
	{
		statesList.add(new OtpErlangAtom(entry.getKey().getStringId()));
		for(Entry<Label,TARGET_TYPE> transition:entry.getValue().entrySet())
		{
			String lblStr = transition.getKey().toErlangTerm();OtpErlangAtom lblAtom = new OtpErlangAtom(lblStr);
			alphabet.put(lblStr,lblAtom);
			for(CmpVertex target:gr.getTargets(transition.getValue()))
				transitions.add(new OtpErlangTuple(new OtpErlangObject[]{new OtpErlangAtom(entry.getKey().getStringId()), lblAtom, new OtpErlangAtom(target.getStringId())}));
		}
	}
	return new OtpErlangTuple(new OtpErlangObject[]{new OtpErlangAtom("statemachine"),new OtpErlangList(statesList.toArray(new OtpErlangObject[0])),
			new OtpErlangList(transitions.toArray(new OtpErlangObject[0])),
			new OtpErlangAtom(gr.getInit().getStringId()),new OtpErlangList(alphabet.values().toArray(new OtpErlangObject[alphabet.size()])),
	});
}
 

import com.ericsson.otp.erlang.OtpErlangObject; //导入依赖的package包/类
/** Only used for testing against runTyperAsAProcess. 
  * @throws IOException */
 protected String runDialyzerAndTyperAsAProcessInsideErlang(File f) throws IOException
 {
 	ErlangRunner.compileErl(f, runner, true);
 	OtpErlangObject otpArgs[] = new OtpErlangObject[]{
     		null, 
	new OtpErlangList(new OtpErlangObject[]{new OtpErlangString(ErlangRunner.getName(f, ERL.BEAM, true))}),
	new OtpErlangString(ErlangRunner.getName(f, ERL.PLT, true)),
	new OtpErlangList(new OtpErlangObject[]{new OtpErlangString(ErlangRunner.getName(f, ERL.ERL, false))}),
	new OtpErlangAtom("text")
};
 	otpArgs[0]=new OtpErlangAtom("dialyzer");
 	runner.call(otpArgs,"Could not run dialyzer");
 	otpArgs[0]=new OtpErlangAtom("typer");
 	OtpErlangTuple response = runner.call(otpArgs,"Could not run typer");
 	return ((OtpErlangString)response.elementAt(1)).stringValue();
 }
 

import com.ericsson.otp.erlang.OtpErlangObject; //导入依赖的package包/类
/** Special case of fsmdiff - disconnected states */
@Test
public void testFsmDiff4()
{
	Configuration config = Configuration.getDefaultConfiguration().copy();config.setGdFailOnDuplicateNames(false);
	LearnerGraphND grA = new LearnerGraphND(config);
	OtpErlangObject grAerlang = ErlangLabel.parseText("{statemachine,['P1000','P1002'],"+
            "[{'P1000','a','P1000'}],"+
            "'P1000',"+
            "['a']}");
	Synapse.StatechumProcess.parseStatemachine(grAerlang,grA,null,true);

	LearnerGraphND grB = new LearnerGraphND(config);
	Synapse.StatechumProcess.parseStatemachine(ErlangLabel.parseText("{statemachine,['P1000','P1001','N1000'],"+
             "[{'P1000','a','P1001'}],"+
             "'P1000',"+
             "['a']}"),grB,null,true);
	
	OtpErlangObject difference = DifferenceVisualiser.ChangesToGraph.computeGD(grA, grB, config);
	Assert.assertEquals("{'statemachinedifference',[{'P1000','a','P1001'}],[{'P1000','a','P1000'}],['N1000','P1001'],['P1002'],[],'P1000'}",ErlangLabel.dumpErlangObject(difference));

	LearnerGraphND shouldBeLikePrevious = new LearnerGraphND(grA,config);
	DifferenceVisualiser.ChangesToGraph.load(difference).applyDiff(shouldBeLikePrevious, config);
	DifferentFSMException ex = WMethod.checkM(grB, shouldBeLikePrevious);
	Assert.assertNull(ex);Assert.assertEquals(grB.getStateNumber(),shouldBeLikePrevious.getStateNumber());
}
 

import com.ericsson.otp.erlang.OtpErlangObject; //导入依赖的package包/类
/** Given that orderedSignatures starts with an atom reflecting the tag of this record, 
    * checking is identical to that for the tuple.
    */
   @Override
public boolean typeCompatible(OtpErlangObject term) 
{
	if (!(term instanceof OtpErlangTuple)) return false;
	OtpErlangTuple tuple = (OtpErlangTuple)term;
	
	if (tuple.arity() != orderedSignatures.size()) return false;
	
	Iterator<Signature> sigIterator = orderedSignatures.iterator();
	for(int i=0;i<orderedSignatures.size();++i)
		if (!sigIterator.next().typeCompatible(tuple.elementAt(i)))
			return false;
	
	return true;
}
 

import com.ericsson.otp.erlang.OtpErlangObject; //导入依赖的package包/类
@Override
public boolean typeCompatible(OtpErlangObject term) 
{
	if (!(term instanceof OtpErlangTuple)) return false;
	OtpErlangTuple tuple = (OtpErlangTuple)term;
	
	if (tuple.arity() != elems.size()) return false;
	
	Iterator<Signature> sigIterator = elems.iterator();
	for(int i=0;i<elems.size();++i)
	{
		Signature sig = sigIterator.next();
		if (!sig.typeCompatible(tuple.elementAt(i)))
			return false;
	}
	return true;
}
 

import com.ericsson.otp.erlang.OtpErlangObject; //导入依赖的package包/类
/** This method is used to check a tail of an improper list. 
 * It returns true if a term can be used to make an improper list, false
 * otherwise and throws an exception if the supplied term represents a non-empty list. */
public static boolean checkEmptyList(OtpErlangObject term) {
	boolean outcome = false;
	if (term instanceof OtpErlangList) {
		if (((OtpErlangList) term).arity() > 0)
			throw new IllegalArgumentException(
					"the tail of an improper list cannot be a non-empty list");
		outcome = true;
	} else if (term instanceof OtpErlangString) {
		if (!((OtpErlangString) term).stringValue().isEmpty())
			throw new IllegalArgumentException(
					"the tail of an improper list cannot be a non-empty string (which is a list)");
		outcome = true;
	}

	return outcome;
}
 

import com.ericsson.otp.erlang.OtpErlangObject; //导入依赖的package包/类
public static String dumpErlangObject(OtpErlangObject obj) {
	StringBuffer buffer = new StringBuffer();
	@SuppressWarnings("rawtypes")
	Class cls = obj.getClass();
	ErlangParserComponent dumper = classToDumper.get(cls);
	while (dumper == null) {
		cls = cls.getSuperclass();
		if (cls == null)
			throw new IllegalArgumentException(
					"cannot dump object of type " + obj.getClass());

		dumper = classToDumper.get(cls);
	}
	dumper.dump(obj, buffer);
	return buffer.toString();
}
 

import com.ericsson.otp.erlang.OtpErlangObject; //导入依赖的package包/类
public ErlangLabel(FuncSignature operator, String shortName,
		OtpErlangObject inputArgs, OtpErlangObject expectedOutputArgs) {
	super(
			// if there is no valid function involved, this label cannot be passed to Erlang.
			operator == null? new OtpErlangObject[]{}:
			expectedOutputArgs == null ? new OtpErlangObject[] {
			// if no outputs, generate a function/input pair
			new OtpErlangAtom(operator.getName()), inputArgs }
			: new OtpErlangObject[] { 
			// with an output, this will be a function/input/output triple.
			new OtpErlangAtom(operator.getName()),inputArgs, expectedOutputArgs });
	arity = expectedOutputArgs == null ? 2 : 3;
	function = operator;
	callName = shortName;
	input = inputArgs;
	expectedOutput = expectedOutputArgs;
	alphaNum = buildFunctionSignatureAsString();
	if (function != null)
		function.typeCompatible(this);
}
 

import com.ericsson.otp.erlang.OtpErlangObject; //导入依赖的package包/类
@Override
public void dump(OtpErlangObject arg, StringBuffer resultHolder) {
	OtpErlangList list = (OtpErlangList) arg;

	resultHolder.append("[");
	boolean first = true;
	for (OtpErlangObject obj : list.elements()) {
		if (!first)
			resultHolder.append(',');
		else
			first = false;
		classToDumper.get(obj.getClass()).dump(obj, resultHolder);
	}
	
	if (!list.isProper())
	{
		OtpErlangObject lastTail = list.getLastTail();resultHolder.append(" | ");
		classToDumper.get(lastTail.getClass()).dump(lastTail, resultHolder);
	}
	resultHolder.append("]");
}
 

import com.ericsson.otp.erlang.OtpErlangObject; //导入依赖的package包/类
/** Tests the extraction of return values. */
@Test
public void testExtractionOfOTPreturnValue5a()
{
	String nestedTerm = "{'Alt',[],[{'Tuple',[],[{'Atom',[],['noreply']},{'Any',[]}]},{'Tuple',[],[{'Atom',[],['stop']},{'Atom',[],['normal']},{'Atom',[],['stopped']}]}]}";
	OtpErlangObject obj = ErlangLabel.parseText("{'Alt',[],[{'Tuple',[],[{'Atom',[],['noreply']},{'Atom',[],['tmp']}]},"+nestedTerm+"]}");
	Signature sig = Signature.buildFromType(defaultConfig, obj);
	Signature conversionResult = new OTPBehaviour.OTPCall().extractVisibleReturnType(sig);
	Assert.assertEquals("{'Alt',[],[{'Atom',[],['tmp']},{'Any',[]},{'Atom',[],['normal']}]}",conversionResult.toErlangTerm());
}
 

import com.ericsson.otp.erlang.OtpErlangObject; //导入依赖的package包/类
@Test
public void testToString6()
{
	Assert.assertEquals("{}",
			ErlangLabel.dumpErlangObject(new OtpErlangTuple(new OtpErlangObject[]{
			})));
}
 

import com.ericsson.otp.erlang.OtpErlangObject; //导入依赖的package包/类
/** Loads a collection of sequences of the form [ [elem1,elem2, ... ], [elem11,elem12, ... ] ] */
@Override
public List<List<String>> readSequenceList(String sequence) 
{
	OtpErlangObject obj = ErlangLabel.parseText(sequence);
	if (!(obj instanceof OtpErlangList))
		throw new IllegalArgumentException("expected a sequence of sequences, got "+obj);
	List<List<String>> outcome = new LinkedList<List<String>>();
	for(OtpErlangObject o:((OtpErlangList)obj))
		outcome.add(readSequenceFromErlangObject(o));
	return outcome;
}