/// /// <summary> * check whether the boolean logic defined by a Test and a test's /// * subelements make sense in the context of the tested element jdf </summary> /// public override bool fitsContext(KElement testElement) { // we only want the leaves as of now if (testElement is JDFResource) { JDFResource r = (JDFResource)testElement; if (!r.isLeaf()) { return(false); } } VElement v = getTermVector(null); int siz = v.Count; for (int i = 0; i < siz; i++) { JDFTerm t = (JDFTerm)v[i]; if (!t.fitsContext(testElement)) // one bad context spoils the // barrell { return(false); } } return(siz > 0); // if no subelements, then no context }
/// /// <summary> * entrySet - Returns a Set view of the entries contained in this Hashtable. Each element in this collection is a /// * Map.Entry. The Set is backed by the Hashtable, so changes to the Hashtable are reflected in the Set, and /// * vice-versa. The Set supports element removal (which removes the corresponding entry from the Hashtable), but not /// * element addition. /// * </summary> /// * <returns> Set - the set view of the entries contained in this hashtable </returns> /// // TODO: Just Delete this? // public virtual Set entrySet() // { ////JAVA TO VB & C# CONVERTER TODO TASK: There is no .NET Dictionary equivalent to the Java 'entrySet' method: // return m_hashTable.entrySet(); // } /// /// <summary> * subMap - returns true if map contains subMap, all keys of submap must be in this hashtable and they must have the /// * same value<br> /// * /// * if subMap is null, the function returns true if subMap contains any wildcards, then the existance of the key in /// * this defines a match /// * </summary> /// * <param name="subMap"> the map to compare /// * </param> /// * <returns> boolean - true if this map contains subMap </returns> /// public virtual bool subMap(JDFAttributeMap subMap) { if (subMap == null) // the null map is a subset of everything { return(true); } ICollection <string> mapSet = this.Keys; ICollection <string> subMapSet = subMap.Keys; if (!this.containsAll(subMapSet)) { return(false); } IEnumerator <string> it = subMapSet.GetEnumerator(); while (it.MoveNext()) { string key = it.Current; string subVal = subMap[key]; if (!KElement.isWildCard(subVal)) { string val = this[key]; if (!val.Equals(subVal)) { return(false); } } } return(true); }
/// /// <summary> * fitsJDF - tests whether JDFNode 'jdf' can be accepted by the Device. /// * Tests if the value of resource attribute, decribed with this Evaluation, /// * fits Evaluation/@ValueList /// * </summary> /// * <param name="jdf"> /// * jdf node to test </param> /// * <returns> boolean - true, if 'jdf' can be accepted by the Device </returns> /// public override bool fitsJDF(KElement jdf, KElement reportRoot) { KElement reportRootLocal = reportRoot; string xPath = getEvalXPath(jdf); if (reportRootLocal != null) { reportRootLocal = reportRootLocal.appendElement(LocalName); } bool b = false; if (xPath != null) { b = fitsPath(jdf, xPath, reportRootLocal); } if (reportRootLocal != null) { reportRootLocal.setAttribute("Value", b, null); reportRootLocal.setAttribute("CapXPath", getRefTargetNamePath()); reportRootLocal.setAttribute("Name", getRefTargetName()); } return(b); }
public virtual void testNonAsciiFileURL() { for (int i = 0; i < 2; i++) // loop over escape and non-escape { FileInfo f = new FileInfo("4€5%äö.txt"); FileInfo f2 = FileUtil.getFileInDirectory(new DirectoryInfo(sm_dirTestDataTemp), f); f2.Delete(); SupportClass.FileSupport.CreateNewFile(f2); f2.Refresh(); Assert.IsTrue(f2.Exists); string url = UrlUtil.fileToUrl(f2, i == 0); XMLDoc doc = new XMLDoc("URL", null); KElement root = doc.getRoot(); root.setAttribute("url", url); doc.write2File(sm_dirTestDataTemp + "url.xml", 2, false); JDFParser p = new JDFParser(); p.bKElementOnly = true; JDFDoc d = p.parseFile(sm_dirTestDataTemp + "url.xml"); KElement root2 = d.getRoot(); string urlParse = root2.getAttribute("url"); Assert.AreEqual(url, urlParse); FileInfo f3 = UrlUtil.urlToFile(urlParse); Assert.AreEqual(f2.FullName, f3.FullName); Assert.IsTrue(f3.Exists); } }
/// /// <summary> * walk the tree starting at e. /// * </summary> /// * <param name="e"> the root element to walk </param> /// * <returns> n the number of traversed elements </returns> /// public virtual int walk(KElement e) { if (e == null) { return(0); } int n = 0; IWalker w = theFactory.getWalker(e); bool b = true; if (w != null) { n++; b = w.walk(e); } if (b) // follow kids if still alive { VElement v = e.getChildElementVector_KElement(null, null, null, true, -1); // do // not // follow // refelements int size = v.Count; for (int i = 0; i < size; i++) { KElement e2 = v[i]; n += walk(e2); } } return(n); }
/// /// <summary> * converts a response to a signal that can be sent individually /// * </summary> /// * <param name="response"> the response to convert </param> /// * <returns> true if successful </returns> /// public virtual bool convertResponse(JDFResponse response, JDFQuery q) { if (response == null) { return(false); } setAttributes(response); VElement elements = response.getChildElementVector(null, null, null, true, 0, true); for (int i = 0; i < elements.Count; i++) { JDFElement element = (JDFElement)elements[i]; copyElement(element, null); } if (q != null) { VElement v = q.getChildElementVector(null, null, null, true, 0, true); for (int i = 0; i < v.Count; i++) { KElement item = v.item(i); if (item is JDFSubscription) { continue; } copyElement(item, null); } } setType(response.getType()); // also fix xsi:type return(true); }
/// /// <summary> * Evaluates two or more Term elements (and, or, xor, not, Evaluation, /// * TestRef) to determine if, as a set, they evaluate to “true” when combined /// * in a boolean “or” function. /// * </summary> /// * <param name="jdf"> /// * JDFNode we test iot know if the Device can accept it </param> /// * <returns> boolean - true, if boolean “or” expression evaluates to “true” </returns> /// public override bool fitsJDF(KElement jdf, KElement reportRoot) { KElement reportRootLocal = reportRoot; VElement v = getTermVector(null); int siz = v.Count; if (reportRootLocal != null) { reportRootLocal = reportRootLocal.appendElement("or"); } bool b = false; for (int i = 0; i < siz; i++) { JDFTerm t = (JDFTerm)v[i]; bool b2 = t.fitsJDF(jdf, reportRootLocal); if (b2 && reportRootLocal == null) { return(true); // don't need complete report and it is true; ciao } b = b || b2; } if (reportRootLocal != null) { reportRootLocal.setAttribute("Value", b, null); } return(b); }
/// /// <summary> * overlapMap - identical keys must have the same values in both maps i.e submap is either a superset or a subset of /// * this /// * </summary> /// * <param name="subMap"> the map to compare with <code>this</this> /// * </param> /// * <returns> boolean - true if identical keys have the same values in both maps </returns> /// public virtual bool overlapMap(JDFAttributeMap subMap) { if (subMap == null || subMap.Count == 0) { return(true); } IEnumerator <string> subMapEnum = subMap.getKeyIterator(); while (subMapEnum.MoveNext()) { string subMapKey = subMapEnum.Current; string subMapVal = subMap[subMapKey]; if (KElement.isWildCard(subMapVal)) { continue; } string val = this[subMapKey]; if (val != null && !subMapVal.Equals(val)) { return(false); } } return(true); }
private static void removePoolElements_Static(KElement root) { VElement v = root.getChildElementVector(null, null, null, true, 0, false); for (int j = v.Count - 1; j >= 0; j--) { KElement el = v[j]; string nam = el.Name; if (nam.Equals("InvalidAttributes") || nam.Equals("InvalidElements") || nam.Equals("UnknownAttributes") || nam.Equals("UnknownElements") || nam.Equals("MissingAttributes")) { moveChildElementVector_Static(root, el); if (!el.hasChildElements() && !el.hasAttributes()) { root.removeChild(el); } } } VElement vv = root.getChildElementVector(null, null, null, true, 0, false); for (int i = vv.Count - 1; i >= 0; i--) { removePoolElements_Static(vv[i]); } return; }
public virtual void testStateReportRequired() { JDFDoc d = new JDFDoc("DevCap"); JDFDevCap dc = (JDFDevCap)d.getRoot(); dc.setName("foo"); JDFIntegerState @is = dc.appendIntegerState(); @is.setName("bar1"); @is.setRequired(true); JDFIntegerState is2 = dc.appendIntegerState(); is2.setName("bar2"); is2.setRequired(false); JDFDoc d2 = new JDFDoc("foo"); KElement foo = d2.getRoot(); JDFDoc d3 = new JDFDoc("parent"); KElement parent = d3.getRoot(); dc.stateReport(foo, EnumFitsValue.Allowed, EnumValidationLevel.Complete, false, true, parent); Assert.IsTrue(parent.ToString().IndexOf("bar1") >= 0); Assert.IsFalse(parent.ToString().IndexOf("bar2") >= 0); }
public void testMarkObject() { JDFDoc doc = new JDFDoc("JDF"); JDFNode root = doc.getJDFRoot(); root.setVersion(EnumVersion.Version_1_4); root.setType(EnumType.Tiling); JDFResourcePool resPool = root.getCreateResourcePool(); KElement kElem = resPool.appendResource(ElementName.TILE, null, null); Assert.IsTrue(kElem is JDFTile); JDFTile tile = ((JDFTile)kElem); try { tile.setClipBox(new JDFRectangle("0 0 123 123")); tile.setCTM(new JDFMatrix("1 0 0 1 0 0")); JDFMarkObject m = tile.appendMarkObject(); m.setOrd(0); m.setCTM(new JDFMatrix("1.2 0 0 1.4 1 444.")); Assert.IsTrue(m.isValid(EnumValidationLevel.Complete)); JDFMarkObject m2 = tile.appendMarkObject(); m2.setOrd(0); m2.setCTM(new JDFMatrix("1.234 0 0 1.4 1 444.")); Assert.IsTrue(m2.isValid(EnumValidationLevel.Complete)); Assert.AreEqual(tile.getMarkObject(1), m2); Assert.AreEqual(tile.getCreateMarkObject(1), m2); Assert.IsTrue(tile.isValid(EnumValidationLevel.Complete)); } catch (FormatException) { Assert.Fail("bad unit matrix"); } }
public virtual void testObjectTagsMetadata() { KElement tagMap = rl.appendElement(METADATA_MAP); tagMap.setXMLComment("This tagmap specifies The path for the NMTOKEN \"ObjectTag\""); tagMap.setAttribute("Name", "ObjectTags"); tagMap.setAttribute(AttributeName.VALUEFORMAT, "%s"); tagMap.setAttribute(AttributeName.CONTEXT, "Object"); tagMap.setAttribute(AttributeName.DATATYPE, "NMTOKEN"); tagMap.setAttribute(AttributeName.VALUETEMPLATE, "AnyName1"); tagMap.addNameSpace("TIFFXMP", "http://ns.adobe.com/tiff/1.0"); string[] ss = new string[] { "Acme", "Bcme", "Ccme" }; for (int i = 0; i < ss.Length; i++) { string s = ss[i]; KElement tagSet = tagMap.appendElement(EXPR); tagSet.setAttribute("Name", "AnyName1"); tagSet.setAttribute("Value", s); JDFStringEvaluation eval = (JDFStringEvaluation)tagSet.appendElement(ElementName.STRINGEVALUATION); eval.setAttribute("Path", "TIFFXMP:Make"); eval.setRegExp("(.*)" + s + "(.*)"); eval.setXMLComment("Any acme camera is mapped to \"" + s + "\""); } JDFColorSpaceConversionParams csp = (JDFColorSpaceConversionParams)root.addResource(ElementName.COLORSPACECONVERSIONPARAMS, EnumUsage.Input); csp.setXMLComment("This ColorSpaceConversionParams treats Acme and Bcme cameras the same but differentiates for Ccme"); JDFColorSpaceConversionOp op1 = csp.appendColorSpaceConversionOp(); op1.setAttribute("ObjectTags", "Acme Bcme"); JDFColorSpaceConversionOp op2 = csp.appendColorSpaceConversionOp(); op2.setAttribute("ObjectTags", "Ccme"); doc.write2File(sm_dirTestDataTemp + "objectTags.jdf", 2, false); }
/// /// <summary> * For KElement 'elem' takes information from parent and children about /// * original and corrected CapXPaths, compare them and set CapXPath as a /// * complete path to this element.<br> /// * Checks CapXPath's for every InvalidResource element of the given XMLDoc /// * and all children (of arbitrary depth). Appends right ancestors if /// * CapXPath is not complete.<br> /// * </summary> /// * <param name="elem"> /// * "pool" element like "InvalidElements" or "InvalidAttributes".<br> /// * From this element we have access to its parent and children /// * and can compare their CapXPath's </param> /// * <param name="originalPath"> /// * parent CapXPath before correction. </param> /// private static void capXPathCorrection_Static(KElement elem, string originalPath) { string parentPath = elem.getParentNode_KElement().getAttribute("CapXPath"); VElement vEl = elem.getChildElementVector(null, null, null, true, 0, false); for (int i = 0; i < vEl.Count; i++) { KElement child = (KElement)vEl[i]; string childPath = child.getAttribute("CapXPath"); if (!parentPath.Equals(JDFConstants.EMPTYSTRING) && !childPath.Equals(JDFConstants.EMPTYSTRING)) { string childPathPart = childPath; if (childPath.StartsWith(originalPath)) { childPathPart = childPath.Substring(originalPath.Length + 1); // +1 removes // "/" } child.setAttribute("CapXPath", parentPath + "/" + childPathPart); // recursion to set everywhere the right CapXPath VElement vSubEl = child.getChildElementVector(null, null, null, true, 0, false); for (int j = 0; j < vSubEl.Count; j++) { capXPathCorrection_Static(vSubEl[j], childPath); } } } return; }
/// /// <summary> * devCapReport - tests if the elements in vElem fit any (logical OR) DevCap /// * element that DevCaps consists of. Composes a detailed report in XML form /// * of the errors found. If XMLDoc is null there are no errors.<br> /// * /// * DevCaps will be checked if they are direct children of <code>this</code> /// * and referenced in DevCapPool. /// * </summary> /// * <param name="vElem"> /// * vector of the elements to test </param> /// * <param name="testlists"> /// * testlists that are specified for the State elements /// * (FitsValue_Allowed or FitsValue_Present)<br> /// * Will be used in fitsValue method of the State element. </param> /// * <param name="level"> /// * validation level </param> /// * <returns> XMLDoc - XMLDoc output of the error messages.<br> /// * If XMLDoc is null there are no errors, every element of vElem /// * fits any DevCap element of <code>this</code>. </returns> /// * <exception cref="JDFException"> /// * if DevCaps/@DevCapRef refers to the DevCap elements in a /// * non-existent DevCapPool </exception> /// * <exception cref="JDFException"> /// * if DevCaps/@DevCapRef refers to the non-existent DevCap </exception> /// public KElement devCapReport(KElement elem, EnumFitsValue testlists, EnumValidationLevel level, bool ignoreExtensions, KElement parentReport) { if (elem == null) { return(null); } VElement dcV = getDevCapVector(); if (dcV == null || dcV.Count == 0) { throw new JDFException("JDFDevCaps.devCapReport: Invalid DeviceCap: DevCaps/@DevCapRef refers to the non-existent DevCap: " + getDevCapRef()); } KElement r = parentReport.appendElement("Invalid" + getContext().getName()); for (int i = 0; i < dcV.Count; i++) { JDFDevCap dc = (JDFDevCap)dcV[i]; KElement stateTestResult = dc.stateReport(elem, testlists, level, ignoreExtensions, true, r); if (stateTestResult == null) { r.deleteNode(); return(null); // first DevCap that fits found -> erase all error // messages } r.setAttribute("XPath", elem.buildXPath(null, 1)); r.setAttribute("Name", getContextName()); r.setAttribute("CapXPath", dc.getName()); } correction_Static(r); return(r); }
public virtual void testValidateCombined() { JDFDoc doc = new JDFDoc("JDF"); JDFValidator checkJDF = new JDFValidator(); checkJDF.setPrint(false); checkJDF.bQuiet = true; JDFNode n = doc.getJDFRoot(); n.setType(EnumType.Combined); int v = 0; while (true) { checkJDF.level = EnumValidationLevel.getEnum(v); if (checkJDF.level == null) { break; } for (int i = 0; i < 3; i++) { if (i >= 1) { doc = null; } XMLDoc schemaValidationResult = checkJDF.processSingleDocument(doc); KElement root = schemaValidationResult.getRoot(); Assert.IsNotNull(root.getXPathElement("TestFile/SchemaValidationOutput")); Assert.IsNotNull(root.getXPathElement("TestFile/CheckJDFOutput")); Assert.AreEqual(root.getXPathAttribute("TestFile/CheckJDFOutput/@IsValid", "booboo"), "true"); } v++; } }
public virtual void testValidatePrivateDoc() { JDFDoc doc = new JDFDoc("JDF"); JDFValidator checkJDF = new JDFValidator(); checkJDF.setPrint(false); checkJDF.bQuiet = true; checkJDF.level = EnumValidationLevel.Incomplete; JDFNode n = doc.getJDFRoot(); checkJDF.setIgnorePrivate(true); n.setAttribute("foo:bar", "foobar", "www.foo.cpm"); XMLDoc schemaValidationResult = checkJDF.processSingleDocument(doc); KElement root = schemaValidationResult.getRoot(); Assert.AreEqual(root.getXPathAttribute("TestFile/CheckJDFOutput/@IsValid", "booboo"), "true"); n.removeAttribute("bar", "www.foo.cpm"); n.appendElement("foo:bar", "www.foo.cpm"); schemaValidationResult = checkJDF.processSingleDocument(doc); root = schemaValidationResult.getRoot(); Assert.AreEqual(root.getXPathAttribute("TestFile[2]/CheckJDFOutput/@IsValid", "booboo"), "true"); n.setAttribute("jdfbar", "thisbebad"); schemaValidationResult = checkJDF.processSingleDocument(doc); root = schemaValidationResult.getRoot(); Assert.AreEqual(root.getXPathAttribute("TestFile[3]/CheckJDFOutput/@IsValid", "booboo"), "false"); n.removeAttribute("jdfbar", null); n.appendElement("jdfbar", null); schemaValidationResult = checkJDF.processSingleDocument(doc); root = schemaValidationResult.getRoot(); Assert.AreEqual(root.getXPathAttribute("TestFile[4]/CheckJDFOutput/@IsValid", "booboo"), "false"); }
/// /// <summary> * Evaluates the boolean expression (child Term element) if it fits the /// * JDFNode 'jdf' a value of true corresponds to a failed test, i.e. the test /// * describes INVALID states for the jdf /// * </summary> /// * <param name="jdf"> /// * JDFNode to test to know if the Device can accept it </param> /// * <param name="reportRoot"> /// * the report to generate. Set to <code>null</code> if no report /// * is requested. </param> /// * <returns> boolean - true, if boolean expression (child Term element) /// * evaluates to “true” </returns> /// public override bool fitsJDF(KElement jdf, KElement reportRoot) { KElement reportRootLocal = reportRoot; if (reportRootLocal != null) { reportRootLocal = reportRootLocal.appendElement("TestReport"); } JDFTerm t = getTerm(); if (t == null) { return(true); // no term --> assume it is a non test; i.e. ok } bool checkContext = true; if (hasAttribute(AttributeName.CONTEXT)) { checkContext = !jdf.matchesPath(getContext(), true); } if (checkContext && !t.fitsContext(jdf)) { return(true); } bool b = t.fitsJDF(jdf, reportRootLocal); if (reportRootLocal != null) { reportRootLocal.setAttribute("Value", b, null); } return(b); }
/// /// <summary> * get resource defined by <code>resNam</code> /// * </summary> /// * <param name="resName"> name of the resource to get, if null get the one and only resource </param> /// * <returns> JDFResource the element, null if none exists </returns> /// public virtual JDFResource getResource(string resName) { if (resName != null) { KElement e = getElement(resName, null, 0); if (e is JDFResource) { return((JDFResource)e); } } else { string resName2 = getResourceName(); if (resName2 != null && !resName2.Equals("")) { return(getResource(resName2)); } KElement e2 = getFirstChildElement(); while (e2 != null) { if (e2 is JDFResource) { return((JDFResource)e2); } e2 = e2.getNextSiblingElement(); } } return(null); }
/// /// <summary> * if this is a new layout, return the partition key signaturename else return Signature/@Name of this or its /// * appropriate parent /// * </summary> /// * <returns> the name of the signature </returns> /// public override string getSignatureName() { if (LocalName.Equals(ElementName.SIGNATURE)) { return(getName()); } if (LocalName.Equals(ElementName.SHEET)) { KElement parentNode = getParentNode_KElement(); if (parentNode is JDFSignature) { JDFSignature sig = (JDFSignature)parentNode; return(sig.getSignatureName()); } } else if (LocalName.Equals(ElementName.SURFACE)) { KElement parentNode = getParentNode_KElement().getParentNode_KElement(); if (parentNode is JDFSignature) { JDFSignature sig = (JDFSignature)parentNode; return(sig.getSignatureName()); } } return(base.getSignatureName()); }
/// /// <summary> * append ResourceLink /// * </summary> /// * <param name="linkName"> name of the ResourceLink to append a link for </param> /// * <param name="bInput"> if true, the link is an input link </param> /// * <returns> JDFResourceLink: the appended element </returns> /// public virtual JDFResourceLink appendResourceLink(string linkName, bool bInput) { string linkNameLocal = linkName; if (!linkNameLocal.EndsWith("Link")) { linkNameLocal += "Link"; } JDFResourceLink rl = null; if (getResourceLink() != null) { throw new JDFException("JDFpipeParams.appendResourceLink tried to append an additional link"); } KElement e = appendElement(linkNameLocal, null); if (e is JDFResourceLink) { rl = (JDFResourceLink)e; rl.setUsage(bInput ? EnumUsage.Input : EnumUsage.Output); } else { throw new JDFException("JDFpipeParams.appendResourceLink tried to return a JDFElement instead of a JDFResourceLink: " + linkNameLocal); } return(rl); }
/// /// <summary> * Inverts the boolean state of a Term child element (and, or, xor, not, /// * Evaluation, TestRef) /// * </summary> /// * <param name="jdf"> /// * JDFNode we test to know if the Device can accept it </param> /// * <param name="reportRoot"> /// * the report to generate. Set to <code>null</code> if no report /// * is requested. </param> /// * <returns> boolean - true, if boolean “not” expression evaluates to “true” </returns> /// public override bool fitsJDF(KElement jdf, KElement reportRoot) { KElement reportRootLocal = reportRoot; VElement v = getTermVector(null); int siz = v.Count; bool b = false; if (reportRootLocal != null) { reportRootLocal = reportRootLocal.appendElement("not"); } int count = 0; for (int i = 0; i < siz; i++) { JDFTerm t = (JDFTerm)v[i]; b = !t.fitsJDF(jdf, reportRootLocal); count++; if (reportRootLocal != null) { reportRootLocal.setAttribute("Value", b, null); } } if (reportRootLocal != null && count != 1) { reportRootLocal.setAttribute("SyntaxWarning", "Warning: not element with more than one term, count=" + Convert.ToString(count)); } return(b); }
public void testSeparationList() { JDFDoc doc = new JDFDoc("JDF"); JDFNode root = doc.getJDFRoot(); JDFResourcePool resPool = root.getCreateResourcePool(); KElement kElem = resPool.appendResource(ElementName.COLORANTCONTROL, null, null); Assert.IsTrue(kElem is JDFColorantControl); JDFColorantControl cc = ((JDFColorantControl)kElem); JDFSeparationList co = cc.appendColorantOrder(); VString seps = new VString(StringUtil.tokenize("Cyan Magenta Yellow Black", " ", false)); co.setSeparations(seps); CollectionAssert.AreEqual(co.getSeparations(), seps); VElement vSepSpec = co.getChildElementVector(ElementName.SEPARATIONSPEC, null, null, true, 0, true); Assert.AreEqual(seps.Count, vSepSpec.Count); for (int i = 0; i < vSepSpec.Count; i++) { Assert.IsFalse(vSepSpec.item(i).hasAttribute(AttributeName.CLASS)); Assert.IsFalse(vSepSpec.item(i) is JDFResource); } Assert.AreEqual("Cyan", co.getSeparation(0)); co.removeSeparation("Magenta"); Assert.AreEqual("Cyan", co.getSeparation(0)); Assert.AreEqual("Yellow", co.getSeparation(1)); Assert.AreEqual("Black", co.getSeparation(2)); Assert.IsNull(co.getSeparation(3)); }
/// /// <summary> * get resource defined by <code>resName</code> /// * </summary> /// * <param name="resName"> name of the resource to get; if null get the resource that is linked by the reslink </param> /// * <returns> JDFResource: the element </returns> /// public virtual JDFResource getResource(string resName) { if (resName == null) { JDFResourceLink rl = getResourceLink(); if (rl != null) { return(rl.getTarget()); } VElement v = getChildElementVector(null, null, null, true, 0, false); for (int i = 0; i < v.Count; i++) { KElement e = v.item(i); if (e is JDFResource) { return((JDFResource)e); } } return(null); } JDFResource r = null; KElement e2 = getElement(resName, null, 0); if (e2 is JDFResource) { r = (JDFResource)e2; } else { throw new JDFException("JDFPipeParams.getResource tried to return a JDFElement instead of a JDFResource"); } return(r); }
public virtual void testIsPresentPartition() { JDFAction act = devicecap.appendActionPool().appendActionTest(EnumTerm.IsPresentEvaluation, true); JDFTest tst = act.getTest(); tst.setContext("//Component"); JDFIsPresentEvaluation ipe = (JDFIsPresentEvaluation)tst.getTerm(); ipe.setRefTarget(ptState); Assert.AreEqual(ptState.getID(), ipe.getrRef()); JDFDoc doc = new JDFDoc("JDF"); JDFNode node = doc.getJDFRoot(); node.setType("fnarf", false); JDFComponent comp = (JDFComponent)node.addResource("Component", null, EnumUsage.Input, null, null, null, null); comp.setProductType("Cover"); XMLDoc rep = new XMLDoc("root", null); KElement eRep = rep.getRoot(); bool fitsJDF = tst.fitsJDF(comp, eRep); Assert.IsTrue(fitsJDF); comp = (JDFComponent)comp.addPartition(EnumPartIDKey.SheetName, "s1"); fitsJDF = tst.fitsJDF(comp, eRep); Assert.IsTrue(fitsJDF, "also partition leaves "); }
public void testSetGetDimension() { JDFDoc doc = new JDFDoc("JDF"); JDFNode root = doc.getJDFRoot(); JDFResourcePool resPool = root.getCreateResourcePool(); KElement kElem = resPool.appendResource(ElementName.MEDIA, EnumResourceClass.Consumable, null); Assert.IsTrue(kElem is JDFMedia); JDFMedia media = ((JDFMedia)kElem); media.setDimensionCM(new JDFXYPair(2.54, 2.54)); JDFXYPair result = media.getDimension(); Assert.AreEqual(new JDFXYPair(72, 72), result); result = media.getDimensionCM(); Assert.AreEqual(new JDFXYPair(2.54, 2.54), result); result = media.getDimensionInch(); Assert.AreEqual(new JDFXYPair(1, 1), result); media.setDimensionInch(new JDFXYPair(1, 1)); result = media.getDimension(); Assert.AreEqual(new JDFXYPair(72, 72), result); result = media.getDimensionCM(); Assert.AreEqual(new JDFXYPair(2.54, 2.54), result); result = media.getDimensionInch(); Assert.AreEqual(new JDFXYPair(1, 1), result); }
public virtual void testValidateJMF() { // Write temp JMF string jmf = "<?xml version='1.0' encoding='UTF-8'?><JMF xmlns='http://www.CIP4.org/JDFSchema_1_1' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' SenderID='Alces' TimeStamp='2004-08-30T17:23:00+01:00' Version='1.2'><Query ID='M001' Type='KnownDevices' xsi:type='QueryKnownDevices'><DeviceFilter DeviceDetails='None'/></Query></JMF>"; FileInfo jmfFile = new FileInfo(Path.Combine(Path.GetTempPath(), "Query-KnownDevices.jmf")); SupportClass.FileSupport.CreateNewFile(jmfFile); // jmfFile.deleteOnExit(); StreamWriter @out = new StreamWriter(new FileStream(jmfFile.FullName, FileMode.Open)); @out.Write(jmf); @out.Close(); jmfFile.Refresh(); Assert.IsTrue(jmfFile.Exists); FileInfo reportFile = new FileInfo(Path.Combine(Path.GetTempPath(), "Queue-KnownDevices-report.xml")); SupportClass.FileSupport.CreateNewFile(reportFile); // reportFile.deleteOnExit(); // Run JDFValidator string[] args = { jmfFile.FullName, "-cq", "-x " + reportFile.FullName }; CheckJDF checker = new CheckJDF(); XMLDoc d = checker.validate(args, null); KElement dRoot = d.getRoot(); Assert.AreEqual("true", dRoot.getXPathAttribute("/CheckOutput/TestFile/CheckJDFOutput/@IsValid", null)); // Check that report exists reportFile.Refresh(); Assert.IsTrue(reportFile.Exists); jmfFile.Delete(); reportFile.Delete(); }
/// /// <summary> * check whether the boolean logic defined by a Test and a test's /// * subelements makes sense in the context of the tested element jdf </summary> /// public override bool fitsContext(KElement testElement) { if (hasAttribute(AttributeName.CONTEXT)) { return(testElement.matchesPath(getContext(), true)); } return(base.fitsContext(testElement)); }
public virtual void testValidateZip() { FileInfo zip = new FileInfo(sm_dirTestData + "checkjdf.zip"); JDFValidator checker = new JDFValidator(); XMLDoc d = checker.processZipFile(zip); KElement root = d.getRoot(); Assert.AreEqual(17, root.numChildElements("TestFile", null), "checkJDF.zip has 17 files"); }
public static KElement appendRefAnchor(JDFMarkObject mark0, string anchor, string anchorType, string rRef) { KElement refAnchor = mark0.getCreateElement("RefAnchor", null, 0); refAnchor.setAttribute("Anchor", anchor); refAnchor.setAttribute("AnchorType", anchorType); refAnchor.setAttribute("rRef", rRef); return(refAnchor); }
/// /// <summary> * increment occurrences by i if this lives in a standard preflight report /// * tree, also increment the appropriate higher up counters /// * </summary> /// * <param name="i"> </param> /// public virtual void addOccurrences(int i, EnumSeverity sev) { addAttribute(AttributeName.OCCURRENCES, i, null); KElement e = getParentNode_KElement(); if (e is JDFPreflightReport) { ((JDFPreflightReport)e).addOccurrences(i, sev); } }