예제 #1
0
        public void ProcProdSched_ReadInvalidQuantityValues()
        {
            // Testing reading an invalid quantity value

            var filepath = TestCommon.TestHelper.TestFileFolder + "\\Neg_ProcessProductionSchedule_InvalidQuantityValue.xml";
            var xmlBytes = System.IO.File.ReadAllBytes(filepath);

            var testObject = new ProcessProductionSchedule(xmlBytes);

            MaterialRequirement materialReq = testObject.ProductionSchedules[0].
                                              ProductionRequests[0].SegmentRequirements[0].MaterialRequirements[0];

            QuantityValue quantityDouble  = materialReq.Quantities[0];
            QuantityValue quantityBoolean = materialReq.Quantities[1];
            QuantityValue quantityInt     = materialReq.Quantities[2];

            // To make sure the raw values have been received as expected:
            Assert.AreEqual("41fs.9", quantityDouble.RawQuantityString);
            Assert.AreEqual("faflse", quantityBoolean.RawQuantityString);
            Assert.AreEqual("0r3", quantityInt.RawQuantityString);

            // Double
            TestCommon.TestHelper.AssertInvalidOperationException(() =>
            {
                quantityDouble.TryParseValueAsXmlDouble();
            },
                                                                  "Failed to parse double");

            // Boolean
            TestCommon.TestHelper.AssertInvalidOperationException(() =>
            {
                quantityBoolean.TryParseValueAsXmlBoolean();
            },
                                                                  "Failed to parse boolean");

            // Int32 (int)
            TestCommon.TestHelper.AssertInvalidOperationException(() =>
            {
                quantityInt.TryParseValueAsXmlInt();
            },
                                                                  "Failed to parse int");

            // Int64 (long)
            TestCommon.TestHelper.AssertInvalidOperationException(() =>
            {
                // Parsing the same value as for Int32
                quantityInt.TryParseValueAsXmlLong();
            },
                                                                  "Failed to parse long");
        }
예제 #2
0
        public void ProcProdSched_Read()
        {
            // Testing reading a regular XML file with all supported features included.

            var filepath = TestCommon.TestHelper.TestFileFolder + "\\ProcessProductionSchedule.xml";
            var xmlBytes = System.IO.File.ReadAllBytes(filepath);

            var testObject = new ProcessProductionSchedule(xmlBytes);

            // Assert creation time
            AssertDateTime(ParseDateTimeInUtc("2019-04-24T14:10:25Z"), testObject.CreationDateTime);

            // Assert schedule count
            Assert.AreEqual(1, testObject.ProductionSchedules.Count);

            // Assert request count
            var schedule1 = testObject.ProductionSchedules[0];

            Assert.AreEqual(2, schedule1.ProductionRequests.Count);


            // Assert request 1

            var request1 = schedule1.ProductionRequests[0];

            Assert.AreEqual(2, request1.SegmentRequirements.Count);

            // Asserting identifier
            Assert.AreEqual("my-identifier-1", request1.Identifier.Value);

            // Asserting hierarchy scope
            Assert.AreEqual("fsf", request1.HierarchyScopeObj.EquipmentIdentifier.Value);
            Assert.AreEqual(EquipmentElementLevelType.ProcessCell, request1.HierarchyScopeObj.EquipmentElementLevel);


            // Asserting one segment requirement

            var segReq1 = request1.SegmentRequirements[0];

            // Assert process segment identifier
            Assert.AreEqual("1", segReq1.ProcessSegmentIdentifier.Value);

            // Assert times
            AssertDateTime(ParseDateTimeInUtc("2019-04-24T15:00:00Z"), segReq1.EarliestStartTime.Value);
            AssertDateTime(ParseDateTimeInUtc("2019-04-24T15:30:00Z"), segReq1.LatestEndTime.Value);

            // Asserting equipment requirement
            Assert.AreEqual(1, segReq1.EquipmentRequirements.Count);
            EquipmentRequirement equipmentReq = segReq1.EquipmentRequirements[0];
            QuantityValue        quantityEquipmentAvailability1 = equipmentReq.Quantities[0];
            QuantityValue        quantityEquipmentAvailability2 = equipmentReq.Quantities[1];

            Assert.AreEqual("false", quantityEquipmentAvailability1.RawQuantityString);
            Assert.AreEqual("true", quantityEquipmentAvailability2.RawQuantityString);
            Assert.IsFalse(quantityEquipmentAvailability1.TryParseValueAsXmlBoolean());
            Assert.IsTrue(quantityEquipmentAvailability2.TryParseValueAsXmlBoolean());
            Assert.AreEqual(DataType.TypeType.booleanXml, quantityEquipmentAvailability1.DataType.Type);
            Assert.AreEqual(DataType.TypeType.booleanXml, quantityEquipmentAvailability2.DataType.Type);

            // Asserting material requirement
            Assert.AreEqual(2, segReq1.MaterialRequirements.Count);
            var matReq = segReq1.MaterialRequirements[0];

            // Asserting material definition ID
            Assert.AreEqual("matte", matReq.MaterialDefinitionIdentifiers[0].Value);
            // Asserting material lot ID
            Assert.AreEqual(1, matReq.MaterialLotIdentifiers.Count);
            Assert.AreEqual("psc2-15", matReq.MaterialLotIdentifiers[0].Value);
            // Assert material use
            Assert.AreEqual(MaterialUseType.Produced, matReq.MaterialUse.Value);
            // Assert quantity 1
            var matProdQuantity1 = matReq.Quantities[0];

            Assert.AreEqual("41.9", matProdQuantity1.RawQuantityString);
            Assert.AreEqual(41.9, matProdQuantity1.TryParseValueAsXmlDouble(), 0.001);
            Assert.AreEqual("t/h", matProdQuantity1.UnitOfMeasure);
            Assert.AreEqual(DataType.TypeType.doubleXml, matProdQuantity1.DataType.Type);
            Assert.AreEqual("ProdRate", matProdQuantity1.Key.Value);
            // Assert quantity 2
            var matProdQuantity2 = matReq.Quantities[1];

            Assert.AreEqual("11.9", matProdQuantity2.RawQuantityString);
            // Not asserting other fields, because this would be redundant to the previous quantity value.
            // -- Asserting assembly requirements. Only one field is included in the test,
            // because the assembly requirements have a structure similar to the enclosing requirements.
            Assert.AreEqual(2, matReq.AssemblyRequirements.Count);
            Assert.AreEqual("Cu", matReq.AssemblyRequirements[0].MaterialDefinitionIdentifiers[0].Value);
            Assert.AreEqual("S", matReq.AssemblyRequirements[1].MaterialDefinitionIdentifiers[0].Value);

            // Asserting another segment requirement (with nested segment requirement)

            var segReq2_1 = request1.SegmentRequirements[1].SegmentRequirements[0];

            AssertDateTime(ParseDateTimeInUtc("2019-04-24T15:31:00Z"), segReq2_1.EarliestStartTime.Value);


            // Assert request 2

            var request2 = schedule1.ProductionRequests[1];

            Assert.AreEqual("my-identifier-2", request2.Identifier.Value);
        }