Codeunit 132207 Library - Assembly

Application Test Library

src/Layers/W1/Tests/ApplicationTestLibrary/LibraryAssembly.Codeunit.al3,290 lines, Copyright (c) Microsoft Corporation. MIT

/// <summary>/// Provides utility functions for creating and managing assembly-related entities in test scenarios, including assembly orders, BOMs, and assembly items./// </summary>codeunit 132207 "Library - Assembly"{    Subtype = Normal;    trigger OnRun()    begin    end;    var        LibraryUtility: Codeunit "Library - Utility";        LibraryCosting: Codeunit "Library - Costing";        LibraryPurchase: Codeunit "Library - Purchase";        LibraryInventory: Codeunit "Library - Inventory";        LibraryERM: Codeunit "Library - ERM";        LibraryDimension: Codeunit "Library - Dimension";        LibraryResource: Codeunit "Library - Resource";        LibraryWarehouse: Codeunit "Library - Warehouse";        Assert: Codeunit Assert;        LibraryRandom: Codeunit "Library - Random";        ChangeType: Option " ",Add,Replace,Delete,Edit,"Delete all","Edit cards";        ErrorZeroQty: Label 'Quantity must have a value in Assembly Header: Document Type=Order, No.=%1. It cannot be zero or empty.';        ErrorStdCost: Label 'Changing Unit Cost or Cost Amount is not allowed when Costing Method is Standard.';        BlockType: Option Dimension,"Dimension Value","Dimension Combination","None";        ClearType: Option "Posting Group","Location Posting Setup","Posting Group Setup";        AdjSource: Option Purchase,Revaluation,"Item Card","Order Lines",Resource,"None";        ErrorDimCombination: Label 'The combination of dimensions used in Order %1%2 is blocked. Dimensions %3 and %4 can''t be used concurrently.', Comment = '%1=OrderNo, %2=LineNo, %3=DimensionCode[1], %4=DimensionCode[2]';        ErrorPostingSetup: Label 'The General Posting Setup does not exist. ';        ErrorInvtPostingSetup: Label 'The Inventory Posting Setup does not exist.';    procedure AddCompInventory(AssemblyHeader: Record "Assembly Header"; PostingDate: Date; QtySupplement: Decimal)    var        AssemblyLine: Record "Assembly Line";        Item: Record Item;    begin        AssemblyLine.Reset();        AssemblyLine.SetRange("Document Type", AssemblyHeader."Document Type");        AssemblyLine.SetRange("Document No.", AssemblyHeader."No.");        AssemblyLine.SetRange(Type, AssemblyLine.Type::Item);        if AssemblyLine.FindSet() then            repeat                Item.Get(AssemblyLine."No.");                if Item.IsInventoriableType() then                    AddItemInventory(                      AssemblyLine, PostingDate, AssemblyLine."Location Code", AssemblyLine."Bin Code", AssemblyLine.Quantity + QtySupplement);            until AssemblyLine.Next() = 0;    end;    procedure AddCompInventoryToBin(AssemblyHeader: Record "Assembly Header"; PostingDate: Date; QtySupplement: Decimal; LocationCode: Code[10]; BinCode: Code[20])    var        AssemblyLine: Record "Assembly Line";        Bin: Record Bin;        Location: Record Location;        ItemJournalTemplate: Record "Item Journal Template";        ItemJournalBatch: Record "Item Journal Batch";        ItemJournalLine: Record "Item Journal Line";        WarehouseJournalTemplate: Record "Warehouse Journal Template";        WarehouseJournalBatch: Record "Warehouse Journal Batch";        WarehouseJournalLine: Record "Warehouse Journal Line";        Item: Record Item;        isDirected: Boolean;    begin        isDirected := false;        if BinCode <> '' then begin            Bin.SetRange(Code, BinCode);            Bin.SetRange("Location Code", LocationCode);            Bin.FindFirst();            Location.Get(LocationCode);            if Location."Directed Put-away and Pick" then                isDirected := true;        end;        SetupItemJournal(ItemJournalTemplate, ItemJournalBatch);        if isDirected then begin            LibraryWarehouse.WarehouseJournalSetup(LocationCode, WarehouseJournalTemplate, WarehouseJournalBatch);            AssemblyLine.Reset();            AssemblyLine.SetRange("Document Type", AssemblyHeader."Document Type");            AssemblyLine.SetRange("Document No.", AssemblyHeader."No.");            AssemblyLine.SetRange(Type, AssemblyLine.Type::Item);            if AssemblyLine.FindSet() then                repeat                    LibraryWarehouse.CreateWhseJournalLine(WarehouseJournalLine, WarehouseJournalTemplate.Name, WarehouseJournalBatch.Name,                      LocationCode, Bin."Zone Code", BinCode,                      WarehouseJournalLine."Entry Type"::"Positive Adjmt.", AssemblyLine."No.", AssemblyLine.Quantity + QtySupplement);                until AssemblyLine.Next() = 0;            LibraryWarehouse.RegisterWhseJournalLine(WarehouseJournalTemplate.Name, WarehouseJournalBatch.Name, LocationCode,              true);            // Add to inventory            Item.SetRange("Location Filter", LocationCode);            LibraryWarehouse.CalculateWhseAdjustment(Item, ItemJournalBatch);        end else begin            AssemblyLine.Reset();            AssemblyLine.SetRange("Document Type", AssemblyHeader."Document Type");            AssemblyLine.SetRange("Document No.", AssemblyHeader."No.");            AssemblyLine.SetRange(Type, AssemblyLine.Type::Item);            if AssemblyLine.FindSet() then                repeat                    LibraryInventory.CreateItemJournalLine(ItemJournalLine, ItemJournalTemplate.Name, ItemJournalBatch.Name,                      ItemJournalLine."Entry Type"::"Positive Adjmt.", AssemblyLine."No.", AssemblyLine.Quantity + QtySupplement);                    ItemJournalLine.Validate("Posting Date", CalcDate('<-1D>', PostingDate));                    ItemJournalLine.Validate("Document Date", CalcDate('<-1D>', ItemJournalLine."Posting Date"));                    ItemJournalLine.Validate("Unit of Measure Code", AssemblyLine."Unit of Measure Code");                    ItemJournalLine.Validate("Variant Code", AssemblyLine."Variant Code");                    ItemJournalLine.Validate("Unit Cost", LibraryRandom.RandDec(50, 2));                    ItemJournalLine.Validate("Location Code", LocationCode);                    ItemJournalLine.Validate("Bin Code", BinCode);                    ItemJournalLine.Modify(true);                until AssemblyLine.Next() = 0;        end;        LibraryInventory.PostItemJournalLine(ItemJournalTemplate.Name, ItemJournalBatch.Name);    end;    procedure AddItemInventory(AssemblyLine: Record "Assembly Line"; PostingDate: Date; LocationCode: Code[10]; BinCode: Code[20]; Qty: Decimal)    var        ItemJournalLine: Record "Item Journal Line";        ItemJournalTemplate: Record "Item Journal Template";        ItemJournalBatch: Record "Item Journal Batch";        Location: Record Location;        Bin: Record Bin;        WarehouseJournalLine: Record "Warehouse Journal Line";        WarehouseJournalTemplate: Record "Warehouse Journal Template";        WarehouseJournalBatch: Record "Warehouse Journal Batch";        Item: Record Item;        isDirected: Boolean;    begin        isDirected := false;        if BinCode <> '' then begin            Bin.SetRange(Code, BinCode);            Bin.SetRange("Location Code", LocationCode);            Bin.FindFirst();            Location.Get(LocationCode);            if Location."Directed Put-away and Pick" then                isDirected := true;        end;        SetupItemJournal(ItemJournalTemplate, ItemJournalBatch);        if isDirected then begin            LibraryWarehouse.WarehouseJournalSetup(LocationCode, WarehouseJournalTemplate, WarehouseJournalBatch);            LibraryWarehouse.CreateWhseJournalLine(WarehouseJournalLine, WarehouseJournalTemplate.Name, WarehouseJournalBatch.Name,              LocationCode, Bin."Zone Code", BinCode,              WarehouseJournalLine."Entry Type"::"Positive Adjmt.", AssemblyLine."No.", Qty);            LibraryWarehouse.RegisterWhseJournalLine(WarehouseJournalTemplate.Name, WarehouseJournalBatch.Name, LocationCode,              true);            // Add to inventory            Item.SetRange("No.", AssemblyLine."No.");            Item.SetRange("Location Filter", LocationCode);            LibraryWarehouse.CalculateWhseAdjustment(Item, ItemJournalBatch);        end else begin            LibraryInventory.CreateItemJournalLine(ItemJournalLine, ItemJournalTemplate.Name, ItemJournalBatch.Name,              ItemJournalLine."Entry Type"::"Positive Adjmt.", AssemblyLine."No.", Qty);            ItemJournalLine.Validate("Posting Date", CalcDate('<-1D>', PostingDate));            ItemJournalLine.Validate("Document Date", CalcDate('<-1D>', ItemJournalLine."Posting Date"));            ItemJournalLine.Validate("Unit of Measure Code", AssemblyLine."Unit of Measure Code");            ItemJournalLine.Validate("Variant Code", AssemblyLine."Variant Code");            ItemJournalLine.Validate("Unit Cost", LibraryRandom.RandDec(50, 2));            ItemJournalLine.Validate("Location Code", LocationCode);            ItemJournalLine.Validate("Bin Code", BinCode);            ItemJournalLine.Modify(true);        end;        LibraryInventory.PostItemJournalLine(ItemJournalTemplate.Name, ItemJournalBatch.Name);    end;    procedure AddAssemblyHeaderComment(AssemblyHeader: Record "Assembly Header"; AssemblyLineNo: Integer)    var        AssemblyCommentLine: Record "Assembly Comment Line";    begin        Clear(AssemblyCommentLine);        AssemblyCommentLine.Init();        AssemblyCommentLine.Validate("Document Type", AssemblyHeader."Document Type");        AssemblyCommentLine.Validate("Document No.", AssemblyHeader."No.");        AssemblyCommentLine.Validate("Document Line No.", AssemblyLineNo);        AssemblyCommentLine.Validate(Comment, 'Order:' + AssemblyHeader."No." + ', Line:' + Format(AssemblyLineNo));        AssemblyCommentLine.Insert(true);    end;    procedure AddAssemblyLineComment(var AssemblyCommentLine: Record "Assembly Comment Line"; DocType: Option; DocumentNo: Code[20]; DocumentLineNo: Integer; Date: Date; Comment: Text[80])    var        RecRef: RecordRef;    begin        Clear(AssemblyCommentLine);        AssemblyCommentLine.Validate("Document Type", DocType);        AssemblyCommentLine.Validate("Document No.", DocumentNo);        AssemblyCommentLine.Validate("Document Line No.", DocumentLineNo);        RecRef.GetTable(AssemblyCommentLine);        AssemblyCommentLine.Validate("Line No.", LibraryUtility.GetNewLineNo(RecRef, AssemblyCommentLine.FieldNo("Line No.")));        AssemblyCommentLine.Insert(true);        AssemblyCommentLine.Validate(Date, Date);        AssemblyCommentLine.Validate(Comment, Comment);        AssemblyCommentLine.Modify(true);    end;    procedure AddEntityDimensions(Type: Enum "BOM Component Type"; No: Code[20])    var        TempDimension: Record Dimension temporary;        TempDimensionValue: Record "Dimension Value" temporary;        DefaultDimension: Record "Default Dimension";        AssemblyLine: Record "Assembly Line";    begin        CreateDimensionSetup(TempDimension, TempDimensionValue);        TempDimension.FindSet();        TempDimensionValue.FindSet();        repeat            case Type of                AssemblyLine.Type::Item:                    LibraryDimension.CreateDefaultDimensionItem(DefaultDimension, No, TempDimension.Code, TempDimensionValue.Code);                AssemblyLine.Type::Resource:                    LibraryDimension.CreateDefaultDimensionResource(DefaultDimension, No, TempDimension.Code, TempDimensionValue.Code);            end;            TempDimensionValue.Next();        until TempDimension.Next() = 0;    end;    procedure BatchPostAssemblyHeaders(var AssemblyHeader: Record "Assembly Header"; PostingDate: Date; ReplacePostingDate: Boolean; ExpectedError: Text[1024])    var        BatchPostAssemblyOrders: Report "Batch Post Assembly Orders";    begin        BatchPostAssemblyOrders.UseRequestPage(false);        BatchPostAssemblyOrders.InitializeRequest(PostingDate, ReplacePostingDate);        BatchPostAssemblyOrders.SetTableView(AssemblyHeader);        if ExpectedError = '' then            BatchPostAssemblyOrders.RunModal()        else begin            #pragma warning disable AS0058, PTE0007 // Accepted violation: this is a test library helper that intentionally wraps asserterror for use by test codeunits.            asserterror BatchPostAssemblyOrders.RunModal();            #pragma warning restore AS0058, PTE0007            Assert.IsTrue(StrPos(GetLastErrorText, ExpectedError) > 0, 'Actual:' + GetLastErrorText);            ClearLastError();        end;    end;    procedure BlockDimensions(TableID: Integer; DimBlockType: Option; EntityNo: Code[20]; OrderNo: Code[20]; LineNo: Text[30]): Text[1024]    var        Dimension: Record Dimension;        DimensionValue: Record "Dimension Value";        DimensionCombination: Record "Dimension Combination";        DefaultDimension: Record "Default Dimension";        DimensionCode: array[5] of Code[20];        "Count": Integer;        ExpectedError: Text[1024];    begin        LibraryDimension.FindDefaultDimension(DefaultDimension, TableID, EntityNo);        DefaultDimension.FindSet();        for Count := 1 to DefaultDimension.Count do begin            DimensionCode[Count] := DefaultDimension."Dimension Code";            DefaultDimension.Next();        end;        ExpectedError := '';        case DimBlockType of            BlockType::Dimension:                begin                    Dimension.Get(DefaultDimension."Dimension Code");                    Dimension.Validate(Blocked, true);                    Dimension.Modify(true);                    ExpectedError := 'Dimension ' + Dimension.Code + ' is blocked.';                end;            BlockType::"Dimension Value":                begin                    DimensionValue.Get(DefaultDimension."Dimension Code", DefaultDimension."Dimension Value Code");                    DimensionValue.Validate(Blocked, true);                    DimensionValue.Modify(true);                    ExpectedError := 'Dimension Value ' + DimensionValue."Dimension Code" + ' - ' + DimensionValue.Code + ' is blocked.';                end;            BlockType::"Dimension Combination":                begin                    DimensionCombination.Get(DimensionCode[1], DimensionCode[2]);                    DimensionCombination.Validate("Combination Restriction", DimensionCombination."Combination Restriction"::Blocked);                    DimensionCombination.Modify(true);                    ExpectedError := StrSubstNo(ErrorDimCombination, OrderNo, LineNo, DimensionCode[1], DimensionCode[2]);                end;        end;        exit(ExpectedError);    end;    procedure BlockOrderDimensions(AssemblyHeader: Record "Assembly Header"; HeaderBlockType: Option; CompBlockType: Option): Text[1024]    var        AssemblyLine: Record "Assembly Line";        TableID: Integer;        HeaderError: Text[1024];        CompError: Text[1024];    begin        AssemblyLine.SetRange("Document Type", AssemblyHeader."Document Type");        AssemblyLine.SetRange("Document No.", AssemblyHeader."No.");        if AssemblyLine.FindFirst() then begin            case AssemblyLine.Type of                AssemblyLine.Type::Item:                    TableID := 27;                AssemblyLine.Type::Resource:                    TableID := 156;                AssemblyLine.Type::" ":                    begin                        TableID := 0;                        AssemblyLine.TestField("Dimension Set ID", 0);                    end;            end;            CompError := BlockDimensions(TableID, CompBlockType, AssemblyLine."No.",                AssemblyLine."Document No.", ', line no. ' + Format(AssemblyLine."Line No."));        end;        HeaderError := BlockDimensions(27, HeaderBlockType, AssemblyHeader."Item No.", AssemblyHeader."No.", '');        if HeaderError <> '' then            exit(HeaderError);        if CompError <> '' then            exit(CompError);        exit('');    end;    procedure CalcExpectedStandardCost(var MaterialCost: Decimal; var CapacityCost: Decimal; var CapOverhead: Decimal; ParentItemNo: Code[20]): Decimal    var        BOMComponent: Record "BOM Component";        Item: Record Item;        Item1: Record Item;        Resource: Record Resource;        ItemUnitOfMeasure: Record "Item Unit of Measure";        ResourceUnitOfMeasure: Record "Resource Unit of Measure";        ExpectedCost: Decimal;        LotSize: Decimal;        LineCost: Decimal;    begin        ExpectedCost := 0;        MaterialCost := 0;        CapacityCost := 0;        CapOverhead := 0;        BOMComponent.SetRange("Parent Item No.", ParentItemNo);        Item.Get(ParentItemNo);        if BOMComponent.FindSet() then            repeat                case BOMComponent.Type of                    BOMComponent.Type::Item:                        begin                            Item1.Get(BOMComponent."No.");                            ItemUnitOfMeasure.Get(Item1."No.", BOMComponent."Unit of Measure Code");                            LineCost := Item1."Unit Cost" * BOMComponent."Quantity per" * ItemUnitOfMeasure."Qty. per Unit of Measure";                            ExpectedCost += LineCost;                            MaterialCost += LineCost;                        end;                    BOMComponent.Type::Resource:                        begin                            Resource.Get(BOMComponent."No.");                            ResourceUnitOfMeasure.Get(Resource."No.", BOMComponent."Unit of Measure Code");                            if (BOMComponent."Resource Usage Type" = BOMComponent."Resource Usage Type"::Direct) or (Item."Lot Size" = 0) then                                LotSize := 1                            else                                LotSize := Item."Lot Size";                            LineCost := (Resource."Unit Cost" * BOMComponent."Quantity per" * ResourceUnitOfMeasure."Qty. per Unit of Measure"                                         ) / LotSize;                            CapOverhead += LineCost - Resource."Direct Unit Cost" *                              BOMComponent."Quantity per" * ResourceUnitOfMeasure."Qty. per Unit of Measure" / LotSize;                            CapacityCost += LineCost;                            ExpectedCost += LineCost;                        end                end;            until BOMComponent.Next() = 0;        if ExpectedCost = 0 then            exit(Item."Standard Cost");        ExpectedCost := ExpectedCost * (1 + Item."Indirect Cost %" / 100) + Item."Overhead Rate";        MaterialCost := Round(MaterialCost, LibraryERM.GetUnitAmountRoundingPrecision());        CapacityCost := Round(CapacityCost, LibraryERM.GetUnitAmountRoundingPrecision());        CapOverhead := Round(CapOverhead, LibraryERM.GetUnitAmountRoundingPrecision());        exit(Round(ExpectedCost, LibraryERM.GetUnitAmountRoundingPrecision()));    end;    procedure CalcExpectedPrice(ParentItemNo: Code[20]): Decimal    var        Item: Record Item;        BOMComponent: Record "BOM Component";        ItemUnitOfMeasure: Record "Item Unit of Measure";        Resource: Record Resource;        ResUnitOfMeasure: Record "Resource Unit of Measure";        ExpectedPrice: Decimal;    begin        ExpectedPrice := 0;        BOMComponent.SetRange("Parent Item No.", ParentItemNo);        BOMComponent.SetRange(Type, BOMComponent.Type::Item);        if BOMComponent.FindSet() then            repeat                Item.Get(BOMComponent."No.");                ItemUnitOfMeasure.Get(Item."No.", BOMComponent."Unit of Measure Code");                ExpectedPrice += Item."Unit Price" * BOMComponent."Quantity per" * ItemUnitOfMeasure."Qty. per Unit of Measure";            until BOMComponent.Next() = 0;        Item.Get(ParentItemNo);        BOMComponent.SetRange(Type, BOMComponent.Type::Resource);        if BOMComponent.FindSet() then            repeat                Resource.Get(BOMComponent."No.");                ResUnitOfMeasure.Get(Resource."No.", BOMComponent."Unit of Measure Code");                ExpectedPrice += Resource."Unit Price" * BOMComponent."Quantity per" * ResUnitOfMeasure."Qty. per Unit of Measure"            until BOMComponent.Next() = 0;        if ExpectedPrice = 0 then            exit(Item."Unit Price");        exit(Round(ExpectedPrice, LibraryERM.GetUnitAmountRoundingPrecision()));    end;    procedure CalcOrderCostAmount(var MaterialCost: Decimal; var ResourceCost: Decimal; var ResourceOvhd: Decimal; var AssemblyOvhd: Decimal; AssemblyHeaderNo: Code[20]): Decimal    var        Item: Record Item;        AssemblyLine: Record "Assembly Line";        AssemblyHeader: Record "Assembly Header";        ExpectedCost: Decimal;        Overhead: Decimal;        IndirectCost: Decimal;        UnitCost: Decimal;        LineCost: Decimal;        LineOverhead: Decimal;    begin        ExpectedCost := 0;        MaterialCost := 0;        ResourceCost := 0;        ResourceOvhd := 0;        AssemblyLine.SetCurrentKey("Document Type", "Document No.", Type);        AssemblyLine.SetRange("Document Type", AssemblyLine."Document Type"::Order);        AssemblyLine.SetRange("Document No.", AssemblyHeaderNo);        AssemblyLine.SetFilter(Type, '<>%1', AssemblyLine.Type::" ");        if AssemblyLine.FindSet() then            repeat                GetCostInformation(UnitCost, Overhead, IndirectCost, AssemblyLine.Type, AssemblyLine."No.", '', '');                LineOverhead := Overhead * AssemblyLine.Quantity * AssemblyLine."Qty. per Unit of Measure";                LineCost := AssemblyLine."Unit Cost" * AssemblyLine.Quantity;                if AssemblyLine.Type = AssemblyLine.Type::Item then                    MaterialCost += LineCost                else begin                    ResourceCost += LineCost;                    ResourceOvhd += LineOverhead;                end            until AssemblyLine.Next() = 0;        AssemblyHeader.Get(AssemblyHeader."Document Type"::Order, AssemblyHeaderNo);        Item.Get(AssemblyHeader."Item No.");        AssemblyOvhd := Item."Indirect Cost %" / 100 * (MaterialCost + ResourceCost + ResourceOvhd) +          Item."Overhead Rate" * AssemblyHeader.Quantity * AssemblyHeader."Qty. per Unit of Measure";        if Item."Costing Method" = Item."Costing Method"::Standard then            exit((Item."Standard Cost" * (100 + Item."Indirect Cost %") / 100 + Item."Overhead Rate") *              AssemblyHeader.Quantity * AssemblyHeader."Qty. per Unit of Measure");        MaterialCost := Round(MaterialCost, LibraryERM.GetAmountRoundingPrecision());        ResourceCost := Round(ResourceCost, LibraryERM.GetAmountRoundingPrecision());        ResourceOvhd := Round(ResourceOvhd, LibraryERM.GetAmountRoundingPrecision());        AssemblyOvhd := Round(AssemblyOvhd, LibraryERM.GetAmountRoundingPrecision());        ExpectedCost := MaterialCost + ResourceCost + ResourceOvhd + AssemblyOvhd;        exit(Round(ExpectedCost, LibraryERM.GetAmountRoundingPrecision()));    end;    procedure ChangeResourceUsage(AssemblyHeaderNo: Code[20])    var        AssemblyLine: Record "Assembly Line";    begin        AssemblyLine.SetCurrentKey("Document Type", "Document No.", Type);        AssemblyLine.SetRange("Document Type", AssemblyLine."Document Type"::Order);        AssemblyLine.SetRange("Document No.", AssemblyHeaderNo);        AssemblyLine.SetRange(Type, AssemblyLine.Type::Resource);        AssemblyLine.Next(LibraryRandom.RandInt(AssemblyLine.Count));        if AssemblyLine."Resource Usage Type" = AssemblyLine."Resource Usage Type"::Fixed then            AssemblyLine.Validate("Resource Usage Type", AssemblyLine."Resource Usage Type"::Direct)        else            AssemblyLine.Validate("Resource Usage Type", AssemblyLine."Resource Usage Type"::Fixed)    end;    procedure ClearOrderPostingSetup(OrderClearType: Option; InvtPostingGroup: Code[20]; GenProdPostingGroup: Code[20]; LocationCode: Code[10]): Text[1024]    var        InventoryPostingSetup: Record "Inventory Posting Setup";        GeneralPostingSetup: Record "General Posting Setup";        ExpectedError: Text[1024];    begin        ExpectedError := '';        case OrderClearType of            ClearType::"Posting Group Setup":                begin                    InventoryPostingSetup.SetRange("Invt. Posting Group Code", InvtPostingGroup);                    if InventoryPostingSetup.FindFirst() then                        InventoryPostingSetup.DeleteAll();                    GeneralPostingSetup.SetRange("Gen. Prod. Posting Group", GenProdPostingGroup);                    if GeneralPostingSetup.FindFirst() then                        GeneralPostingSetup.DeleteAll();                    ExpectedError := ErrorPostingSetup;                end;            ClearType::"Location Posting Setup":                begin                    InventoryPostingSetup.SetRange("Location Code", LocationCode);                    InventoryPostingSetup.SetRange("Invt. Posting Group Code", InvtPostingGroup);                    if InventoryPostingSetup.FindFirst() then                        InventoryPostingSetup.DeleteAll();                    ExpectedError := ErrorInvtPostingSetup;                end;        end;        exit(ExpectedError);    end;    local procedure CreateAssemblyHeaderLocal(var AssemblyHeader: Record "Assembly Header"; DueDate: Date; ParentItemNo: Code[20]; LocationCode: Code[10]; Quantity: Decimal; DocumentType: Enum "Assembly Document Type"; VariantCode: Code[10]): Code[20]    begin        Clear(AssemblyHeader);        AssemblyHeader."Document Type" := DocumentType;        AssemblyHeader.Insert(true);        AssemblyHeader.Validate("Item No.", ParentItemNo);        AssemblyHeader.Validate("Location Code", LocationCode);        AssemblyHeader.Validate("Due Date", DueDate);        AssemblyHeader.Validate(Quantity, Quantity);        if VariantCode <> '' then            AssemblyHeader.Validate("Variant Code", VariantCode);        AssemblyHeader.Modify(true);        exit(AssemblyHeader."No.");    end;    procedure CreateAssemblyHeader(var AssemblyHeader: Record "Assembly Header"; DueDate: Date; ParentItemNo: Code[20]; LocationCode: Code[10]; Quantity: Decimal; VariantCode: Code[10]): Code[20]    begin        exit(          CreateAssemblyHeaderLocal(            AssemblyHeader, DueDate, ParentItemNo, LocationCode, Quantity, AssemblyHeader."Document Type"::Order, VariantCode));    end;    procedure CreateAssemblyQuote(var AssemblyHeader: Record "Assembly Header"; DueDate: Date; ParentItemNo: Code[20]; LocationCode: Code[10]; Quantity: Decimal; VariantCode: Code[10]): Code[20]    begin        exit(          CreateAssemblyHeaderLocal(            AssemblyHeader, DueDate, ParentItemNo, LocationCode, Quantity, AssemblyHeader."Document Type"::Quote, VariantCode));    end;    procedure CreateAssemblyLine(AssemblyHeader: Record "Assembly Header"; var AssemblyLine: Record "Assembly Line"; Type: Enum "BOM Component Type"; No: Code[20]; UOMCode: Code[10]; Quantity: Decimal; QtyPer: Decimal; Desc: Text[100])    var        RecRef: RecordRef;    begin        Clear(AssemblyLine);        AssemblyLine."Document Type" := AssemblyHeader."Document Type";        AssemblyLine."Document No." := AssemblyHeader."No.";        RecRef.GetTable(AssemblyLine);        AssemblyLine.Validate("Line No.", LibraryUtility.GetNewLineNo(RecRef, AssemblyLine.FieldNo("Line No.")));        AssemblyLine.Insert(true);        AssemblyLine.Validate(Type, Type);        AssemblyLine.Validate("No.", No);        if AssemblyHeader.Quantity <> 0 then            AssemblyLine."Quantity per" := AssemblyLine.CalcQuantityPer(Quantity);        AssemblyLine.Validate(Quantity, Quantity);        AssemblyLine.Validate("Unit of Measure Code", UOMCode);        if QtyPer <> 0 then            AssemblyLine.Validate("Quantity per", QtyPer);        AssemblyLine.Validate(Description, Desc);        AssemblyLine.Modify(true);    end;    procedure CreateAssemblyLines(CostingMethod: Enum "Costing Method"; AssemblyHeaderNo: Code[20]; NoOfItems: Integer; NoOfResources: Integer)    var        AssemblyHeader: Record "Assembly Header";        TempItem: Record Item temporary;        TempResource: Record Resource temporary;        AssemblyLine: Record "Assembly Line";    begin        SetupComponents(TempItem, TempResource, CostingMethod, NoOfItems, NoOfResources, '', '');        AssemblyHeader.Get(AssemblyHeader."Document Type"::Order, AssemblyHeaderNo);        if TempItem.FindSet() then            repeat                CreateAssemblyLine(AssemblyHeader, AssemblyLine, "BOM Component Type"::Item, TempItem."No.",                  GetUnitOfMeasureCode("BOM Component Type"::Item, TempItem."No.", true), LibraryRandom.RandDec(20, 2), 0, '');            until TempItem.Next() = 0;        if TempResource.FindSet() then            repeat                CreateAssemblyLine(AssemblyHeader, AssemblyLine, "BOM Component Type"::Resource, TempResource."No.",                  GetUnitOfMeasureCode("BOM Component Type"::Resource, TempResource."No.", true), LibraryRandom.RandDec(20, 2), 0, '');            until TempResource.Next() = 0;    end;    procedure CreateAssemblyList(CostingMethod: Enum "Costing Method"; ParentItemNo: Code[20]; UseBaseUnitOfMeasure: Boolean; NoOfItems: Integer; NoOfResources: Integer; NoOfTexts: Integer; QtyPerFactor: Integer; GenProdPostingGroup: Code[20]; InventoryPostingGroup: Code[20])    var        BOMComponent: Record "BOM Component";        TempItem: Record Item temporary;        TempResource: Record Resource temporary;        CompCount: Integer;    begin        SetupComponents(TempItem, TempResource, CostingMethod, NoOfItems, NoOfResources, GenProdPostingGroup, InventoryPostingGroup);        if TempItem.FindSet() then            repeat                CreateAssemblyListComponent(BOMComponent.Type::Item, TempItem."No.", ParentItemNo, '',                  BOMComponent."Resource Usage Type"::Direct, QtyPerFactor * LibraryRandom.RandDec(20, 5), UseBaseUnitOfMeasure);            until TempItem.Next() = 0;        CompCount := 1;        if TempResource.FindSet() then            repeat                if CompCount mod 2 = 0 then                    CreateAssemblyListComponent(BOMComponent.Type::Resource, TempResource."No.", ParentItemNo, '',                      BOMComponent."Resource Usage Type"::Direct, QtyPerFactor * LibraryRandom.RandDec(20, 5), UseBaseUnitOfMeasure)                else                    CreateAssemblyListComponent(BOMComponent.Type::Resource, TempResource."No.", ParentItemNo, '',                      BOMComponent."Resource Usage Type"::Fixed, QtyPerFactor * LibraryRandom.RandDec(20, 5), UseBaseUnitOfMeasure);                CompCount += 1;            until TempResource.Next() = 0;        for CompCount := 1 to NoOfTexts do            CreateAssemblyListComponent(BOMComponent.Type::" ", '', ParentItemNo, '',              BOMComponent."Resource Usage Type"::Direct, 0, UseBaseUnitOfMeasure);        Commit();    end;    procedure CreateAssemblyListComponent(ComponentType: Enum "BOM Component Type"; ComponentNo: Code[20]; ParentItemNo: Code[20]; VariantCode: Code[10]; ResourceUsage: Option; Qty: Decimal; UseBaseUnitOfMeasure: Boolean)    var        BOMComponent: Record "BOM Component";    begin        LibraryInventory.CreateBOMComponent(            BOMComponent, ParentItemNo, ComponentType, ComponentNo, Qty, GetUnitOfMeasureCode(ComponentType, ComponentNo, UseBaseUnitOfMeasure));        if ComponentType = BOMComponent.Type::Resource then            BOMComponent.Validate("Resource Usage Type", ResourceUsage);        BOMComponent.Validate("Variant Code", VariantCode);        BOMComponent.Validate(          Description, LibraryUtility.GenerateRandomCode(BOMComponent.FieldNo(Description), DATABASE::"BOM Component"));        BOMComponent.Modify(true);        Commit();    end;    procedure CreateAssemblySetup(var AssemblySetup: Record "Assembly Setup"; LocationCode: Code[10]; DimensionsFrom: Option; PostedOrdersNo: Code[20])    begin        if AssemblySetup."Assembly Order Nos." = '' then            AssemblySetup.Validate("Assembly Order Nos.",              LibraryUtility.GetGlobalNoSeriesCode());        if AssemblySetup."Posted Assembly Order Nos." = '' then            AssemblySetup.Validate("Posted Assembly Order Nos.", LibraryUtility.GetGlobalNoSeriesCode());        if AssemblySetup."Assembly Quote Nos." = '' then            AssemblySetup.Validate("Assembly Quote Nos.", LibraryUtility.GetGlobalNoSeriesCode());        if AssemblySetup."Blanket Assembly Order Nos." = '' then            AssemblySetup.Validate("Blanket Assembly Order Nos.", LibraryUtility.GetGlobalNoSeriesCode());        AssemblySetup.Validate("Default Location for Orders", LocationCode);        AssemblySetup.Validate("Copy Component Dimensions from", DimensionsFrom);        AssemblySetup.Validate("Posted Assembly Order Nos.", PostedOrdersNo);        AssemblySetup.Modify(true);    end;    procedure CreateDimensionSetup(var TempDimension: Record Dimension temporary; var TempDimensionValue: Record "Dimension Value" temporary)    var        DimensionValue: Record "Dimension Value";        DimensionCombination: Record "Dimension Combination";        Dimension: Record Dimension;        "Count": Integer;        DimensionCode: array[5] of Code[20];    begin        for Count := 1 to 2 do begin            LibraryDimension.CreateDimension(Dimension);            DimensionCode[Count] := Dimension.Code;            TempDimension := Dimension;            TempDimension.Insert();            LibraryDimension.CreateDimensionValue(DimensionValue, Dimension.Code);            TempDimensionValue := DimensionValue;            TempDimensionValue.Insert();        end;        LibraryDimension.CreateDimensionCombination(DimensionCombination, DimensionCode[1], DimensionCode[2]);    end;    procedure CreateGLAccount(var GLAccount: Record "G/L Account"; IncomeBalance: Enum "G/L Account Report Type"; Name: Text[30])    begin        LibraryERM.CreateGLAccount(GLAccount);        GLAccount.Validate("Income/Balance", IncomeBalance);        GLAccount.Validate("Debit/Credit", GLAccount."Debit/Credit"::Both);        GLAccount.Validate("Account Type", GLAccount."Account Type"::Posting);        GLAccount.Validate(Name, Name);        GLAccount.Modify(true);    end;    procedure CreateItem(var Item: Record Item; CostingMethod: Enum "Costing Method"; ReplenishmentMethod: Enum "Replenishment System"; GenProdPostingGroup: Code[20]; InventoryPostingGroup: Code[20]): Code[20]    var        GeneralPostingSetup: Record "General Posting Setup";        ItemUnitOfMeasure: Record "Item Unit of Measure";        UnitOfMeasure: Record "Unit of Measure";        VATPostingSetup: Record "VAT Posting Setup";    begin        LibraryInventory.CreateItem(Item);        Item.Validate("Replenishment System", ReplenishmentMethod);        Item.Validate("Costing Method", CostingMethod);        if ReplenishmentMethod <> Item."Replenishment System"::Assembly then begin            if CostingMethod = Item."Costing Method"::Standard then                Item.Validate("Standard Cost", LibraryRandom.RandDec(25, 2))            else                Item.Validate("Unit Cost", LibraryRandom.RandDec(25, 2));            Item.Validate("Unit Price", Item."Unit Cost" + LibraryRandom.RandDec(25, 2));        end else begin            Item.Validate("Standard Cost", 0);            Item.Validate("Unit Cost", 0);            Item.Validate("Unit Price", 0);        end;        Item.Validate("Last Direct Cost", Item."Unit Cost");        if InventoryPostingGroup <> '' then            Item.Validate("Inventory Posting Group", InventoryPostingGroup);        if GenProdPostingGroup = '' then begin            LibraryERM.FindGeneralPostingSetupInvtToGL(GeneralPostingSetup);            GenProdPostingGroup := GeneralPostingSetup."Gen. Prod. Posting Group";        end;        Item.Validate("Gen. Prod. Posting Group", GenProdPostingGroup);        Clear(VATPostingSetup);        LibraryERM.FindVATPostingSetup(VATPostingSetup, VATPostingSetup."VAT Calculation Type"::"Normal VAT");        Item.Validate("VAT Prod. Posting Group", VATPostingSetup."VAT Prod. Posting Group");        Item.Modify(true);        UnitOfMeasure.SetFilter(Code, '<>%1', Item."Base Unit of Measure");        UnitOfMeasure.FindFirst();        LibraryInventory.CreateItemUnitOfMeasure(          ItemUnitOfMeasure, Item."No.", UnitOfMeasure.Code, LibraryRandom.RandInt(10));        exit(Item."No.");    end;    procedure CreateInvtPostingSetup(var InventoryPostingSetup: Record "Inventory Posting Setup"; LocationCode: Code[10]; InvtPostingGroupCode: Code[20]; InvtAccount: Code[20]; MatVarAccount: Code[20]; CapVarAcc: Code[20]; CapOvhdVarAcc: Code[20]; MfgOvhdVarAcc: Code[20]; InvtAccInterim: Code[20])    var        GLAccount: Record "G/L Account";    begin        Clear(InventoryPostingSetup);        InventoryPostingSetup.Init();        InventoryPostingSetup.Validate("Location Code", LocationCode);        InventoryPostingSetup.Validate("Invt. Posting Group Code", InvtPostingGroupCode);        InventoryPostingSetup.Validate("Inventory Account", InvtAccount);        InventoryPostingSetup.Validate("Material Variance Account", MatVarAccount);        InventoryPostingSetup.Validate("Capacity Variance Account", CapVarAcc);        InventoryPostingSetup.Validate("Cap. Overhead Variance Account", CapOvhdVarAcc);        InventoryPostingSetup.Validate("Mfg. Overhead Variance Account", MfgOvhdVarAcc);        InventoryPostingSetup.Validate("Inventory Account (Interim)", InvtAccInterim);        LibraryERM.CreateGLAccount(GLAccount);        InventoryPostingSetup.Validate("WIP Account", GLAccount."No.");        OnBeforeInsertInventoryPostingSetup(InventoryPostingSetup);        InventoryPostingSetup.Insert(true);    end;    procedure CreateInvtMovement(AssemblyHeaderNo: Code[20]; NewCreateInvtPutAway: Boolean; NewCreateInvtPick: Boolean; NewCreateInvtMovement: Boolean)    var        TmpWarehouseRequest: Record "Warehouse Request";        WarehouseRequest: Record "Warehouse Request";        CreateInvtPutAwayPick: Report "Create Invt Put-away/Pick/Mvmt";    begin        WarehouseRequest.SetCurrentKey("Source Document", "Source No.");        WarehouseRequest.SetRange("Source Document", WarehouseRequest."Source Document"::"Assembly Consumption");        WarehouseRequest.SetRange("Source No.", AssemblyHeaderNo);        Commit();        CreateInvtPutAwayPick.InitializeRequest(          NewCreateInvtPutAway, NewCreateInvtPick, NewCreateInvtMovement, false, false);        if WarehouseRequest.HasFilter then            TmpWarehouseRequest.CopyFilters(WarehouseRequest)        else begin            WarehouseRequest.Get(WarehouseRequest.Type,              WarehouseRequest."Location Code",              WarehouseRequest."Source Type",              WarehouseRequest."Source Subtype",              WarehouseRequest."Source No.");            TmpWarehouseRequest.SetRange(Type, WarehouseRequest.Type);            TmpWarehouseRequest.SetRange("Location Code", WarehouseRequest."Location Code");            TmpWarehouseRequest.SetRange("Source Type", WarehouseRequest."Source Type");            TmpWarehouseRequest.SetRange("Source Subtype", WarehouseRequest."Source Subtype");            TmpWarehouseRequest.SetRange("Source No.", WarehouseRequest."Source No.");        end;        CreateInvtPutAwayPick.SetTableView(TmpWarehouseRequest);        CreateInvtPutAwayPick.UseRequestPage(false);        CreateInvtPutAwayPick.RunModal();    end;    procedure AsmOrder_CreateInvtMovement(var WarehouseRequest: Record "Warehouse Request"; NewCreateInvtPutAway: Boolean; NewCreateInvtPick: Boolean; NewCreateInvtMovement: Boolean; NewPrintDocument: Boolean; NewShowError: Boolean)    var        TmpWarehouseRequest: Record "Warehouse Request";        CreateInvtPutAwayPick: Report "Create Invt Put-away/Pick/Mvmt";    begin        Commit();        CreateInvtPutAwayPick.InitializeRequest(          NewCreateInvtPutAway, NewCreateInvtPick, NewCreateInvtMovement, NewPrintDocument, NewShowError);        if WarehouseRequest.HasFilter then            TmpWarehouseRequest.CopyFilters(WarehouseRequest)        else begin            WarehouseRequest.Get(WarehouseRequest.Type,              WarehouseRequest."Location Code",              WarehouseRequest."Source Type",              WarehouseRequest."Source Subtype",              WarehouseRequest."Source No.");            TmpWarehouseRequest.SetRange(Type, WarehouseRequest.Type);            TmpWarehouseRequest.SetRange("Location Code", WarehouseRequest."Location Code");            TmpWarehouseRequest.SetRange("Source Type", WarehouseRequest."Source Type");            TmpWarehouseRequest.SetRange("Source Subtype", WarehouseRequest."Source Subtype");            TmpWarehouseRequest.SetRange("Source No.", WarehouseRequest."Source No.");        end;        CreateInvtPutAwayPick.SetTableView(TmpWarehouseRequest);        CreateInvtPutAwayPick.UseRequestPage(false);        CreateInvtPutAwayPick.RunModal();    end;    procedure CreateWhsePick(AssemblyHeader: Record "Assembly Header"; AssignedUserID: Code[50]; SortingMethod: Option; SetBreakBulkFilter: Boolean; DoNotFillQtyToHandle: Boolean; PrintDocument: Boolean)    begin        AssemblyHeader.CreatePick(false, AssignedUserID, SortingMethod, SetBreakBulkFilter, DoNotFillQtyToHandle, PrintDocument);    end;    procedure CreateMultipleLvlTree(var Item: Record Item; var Item1: Record Item; ReplenishmentMethod: Enum "Replenishment System"; CostingMethod: Enum "Costing Method"; TreeDepth: Integer; NoOfComps: Integer)    var        BOMComponent: Record "BOM Component";        Item2: Record Item;        Depth: Integer;        BOMCreated: Boolean;    begin        CreateItem(Item, CostingMethod, ReplenishmentMethod, '', '');        BOMCreated := false;        OnCreateMultipleLvlTreeOnCreateBOM(Item, NoOfComps, BOMCreated);        if not BOMCreated then            CreateAssemblyList(Item."Costing Method"::Standard, Item."No.", true, NoOfComps, NoOfComps, NoOfComps, 1, '', '');        CreateItem(Item1, Item."Costing Method"::Standard, Item."Replenishment System"::Assembly, '', '');        CreateAssemblyList(Item."Costing Method"::Standard, Item1."No.", true, 2, 1, 0, 1, '', '');        CreateAssemblyListComponent(          BOMComponent.Type::Item, Item."No.", Item1."No.", '', BOMComponent."Resource Usage Type"::Direct,          LibraryRandom.RandDec(20, 2), true);        for Depth := 2 to TreeDepth do begin            CreateItem(Item2, Item."Costing Method"::Standard, Item."Replenishment System"::Assembly, '', '');            CreateAssemblyList(Item."Costing Method"::Standard, Item2."No.", true, 2, 1, 0, 1, '', '');            CreateAssemblyListComponent(BOMComponent.Type::Item, Item1."No.", Item2."No.", '', BOMComponent."Resource Usage Type"::Direct,              LibraryRandom.RandDec(20, 2), true);            Item := Item1;            Item1 := Item2;            Item.Find();            Item.Validate("Replenishment System", ReplenishmentMethod);            Item.Modify(true);            OnCreateMultipleLvlTreeOnCreateBOM(Item, NoOfComps, BOMCreated);        end;        Commit();    end;    procedure CreateItemSubstitution(var ItemSubstitution: Record "Item Substitution"; ItemNo: Code[20])    var        Item1: Record Item;    begin        CreateItem(Item1, Item1."Costing Method"::Standard, Item1."Replenishment System"::Purchase, '', '');        Clear(ItemSubstitution);        ItemSubstitution.Init();        ItemSubstitution.Validate(Type, ItemSubstitution.Type::Item);        ItemSubstitution.Validate("No.", ItemNo);        ItemSubstitution.Validate("Substitute Type", ItemSubstitution."Substitute Type"::Item);        ItemSubstitution.Validate("Substitute No.", Item1."No.");        ItemSubstitution.Insert();    end;    procedure CreateAdjustmentSource(AssemblyHeader: Record "Assembly Header"; PostingDate: Date; AdjustHeader: Boolean; AdjustmentSource: Option; ItemNo: Code[20]; ResourceNo: Code[20])    var        PurchaseHeader: Record "Purchase Header";        PurchaseLine: Record "Purchase Line";        Item: Record Item;        ItemJournalLine: Record "Item Journal Line";        Resource: Record Resource;    begin        if AdjustHeader then            ItemNo := AssemblyHeader."Item No.";        Item.Get(ItemNo);        case AdjustmentSource of            AdjSource::Purchase:                begin                    LibraryPurchase.CreatePurchHeader(                      PurchaseHeader, PurchaseHeader."Document Type"::Order, '');                    LibraryPurchase.CreatePurchaseLine(                      PurchaseLine, PurchaseHeader, PurchaseLine.Type::Item, ItemNo, LibraryRandom.RandInt(10));                    PurchaseHeader.Validate(                      "Vendor Invoice No.", LibraryUtility.GenerateRandomCode(PurchaseHeader.FieldNo("Vendor Invoice No."),                        DATABASE::"Purchase Header"));                    PurchaseHeader.Modify(true);                    LibraryPurchase.PostPurchaseDocument(PurchaseHeader, true, true);                end;            AdjSource::Revaluation:                begin                    RevaluateItem(Item, ItemJournalLine, Item."Unit Cost", PostingDate);                    LibraryInventory.PostItemJournalLine(ItemJournalLine."Journal Template Name", ItemJournalLine."Journal Batch Name");                end;            AdjSource::"Item Card":                begin                    Item."Unit Cost" := Item."Unit Cost" + LibraryRandom.RandDec(10, 2);                    if Item."Costing Method" = Item."Costing Method"::Standard then                        Item."Standard Cost" := Item."Standard Cost" + LibraryRandom.RandDec(10, 2);                    Item.Modify(true);                end;            AdjSource::"Order Lines":                begin                    ResourceNo := CreateResource(Resource, true, Item."Gen. Prod. Posting Group");                    EditAssemblyLines(ChangeType::Add, "BOM Component Type"::Resource, "BOM Component Type"::Resource, ResourceNo,                      AssemblyHeader."No.", true);                end;            AdjSource::Resource:                begin                    Resource.Get(ResourceNo);                    Resource."Unit Cost" := Resource."Unit Cost" + LibraryRandom.RandDec(10, 2);                    Resource.Modify(true);                end        end;    end;    procedure CreateItemWithSKU(var Item: Record Item; CostingMethod: Enum "Costing Method"; ReplenishmentSystem: Enum "Replenishment System"; CreatePer: Enum "SKU Creation Method"; GenProdPostingGr: Code[20]; InvtPostingGr: Code[20]; LocationCode: Code[10])    var        ItemVariant: Record "Item Variant";    begin        CreateItem(Item, CostingMethod, ReplenishmentSystem, GenProdPostingGr, InvtPostingGr);        if CreatePer <> CreatePer::Location then            LibraryInventory.CreateVariant(ItemVariant, Item);        Item."Location Filter" := LocationCode;        Item.Modify();        Item.SetRange("Location Filter", LocationCode);        Item.SetRecFilter();        LibraryInventory.CreateStockKeepingUnit(Item, CreatePer, false, true);        UpdateSKUCards(Item);    end;    procedure CheckOrderDimensions(AssemblyHeader: Record "Assembly Header"; DimensionsFrom: Option)    var        AssemblyLine: Record "Assembly Line";        AssemblySetup: Record "Assembly Setup";        TableID: Integer;    begin        VerifyEntityDimensions(          DATABASE::Item, AssemblyHeader."Item No.", AssemblyHeader."Item No.", true, AssemblyHeader."Dimension Set ID");        AssemblyLine.SetRange("Document Type", AssemblyHeader."Document Type");        AssemblyLine.SetRange("Document No.", AssemblyHeader."No.");        if AssemblyLine.FindSet() then            repeat                case AssemblyLine.Type of                    AssemblyLine.Type::Item:                        TableID := DATABASE::Item;                    AssemblyLine.Type::Resource:                        TableID := DATABASE::Resource;                    AssemblyLine.Type::" ":                        begin                            TableID := 0;                            AssemblyLine.TestField("Dimension Set ID", 0);                        end;                end;                VerifyEntityDimensions(                  TableID, AssemblyLine."No.", AssemblyHeader."Item No.",                  DimensionsFrom = AssemblySetup."Copy Component Dimensions from"::"Order Header",                  AssemblyLine."Dimension Set ID");            until AssemblyLine.Next() = 0;    end;    procedure CreateResource(var Resource: Record Resource; UseRelatedUnitOfMeasure: Boolean; GenProdPostingGroup: Code[20]): Code[20]    var        GeneralPostingSetup: Record "General Posting Setup";        ResourceUnitOfMeasure: Record "Resource Unit of Measure";        UnitOfMeasure: Record "Unit of Measure";        VATPostingSetup: Record "VAT Posting Setup";    begin        LibraryERM.FindVATPostingSetup(VATPostingSetup, VATPostingSetup."VAT Calculation Type"::"Normal VAT");        LibraryResource.CreateResource(Resource, VATPostingSetup."VAT Bus. Posting Group");        UnitOfMeasure.SetFilter(Code, '<>%1', Resource."Base Unit of Measure");        UnitOfMeasure.FindFirst();        // Add a second non-base unit of measure.        Clear(ResourceUnitOfMeasure);        ResourceUnitOfMeasure.Init();        ResourceUnitOfMeasure.Validate("Resource No.", Resource."No.");        ResourceUnitOfMeasure.Validate(Code, UnitOfMeasure.Code);        ResourceUnitOfMeasure.Insert(true);        ResourceUnitOfMeasure.Validate("Qty. per Unit of Measure", LibraryRandom.RandInt(10));        ResourceUnitOfMeasure.Validate("Related to Base Unit of Meas.", UseRelatedUnitOfMeasure);        ResourceUnitOfMeasure.Modify(true);        if GenProdPostingGroup = '' then begin            LibraryERM.FindGeneralPostingSetupInvtToGL(GeneralPostingSetup);            GenProdPostingGroup := GeneralPostingSetup."Gen. Prod. Posting Group";        end;        Resource.Validate("Gen. Prod. Posting Group", GenProdPostingGroup);        Resource.Modify(true);        exit(Resource."No.")    end;    procedure DeleteAssemblyLine(ComponentType: Enum "BOM Component Type"; AssemblyHeaderNo: Code[20])    var        AssemblyLine: Record "Assembly Line";    begin        AssemblyLine.SetCurrentKey("Document Type", "Document No.", Type);        AssemblyLine.SetRange("Document Type", AssemblyLine."Document Type"::Order);        AssemblyLine.SetRange("Document No.", AssemblyHeaderNo);        AssemblyLine.SetRange(Type, ComponentType);        if not AssemblyLine.FindSet() then            exit;        AssemblyLine.Next(LibraryRandom.RandInt(AssemblyLine.Count));        AssemblyLine.Delete();    end;    procedure DeleteAssemblyLines(AssemblyHeaderNo: Code[20])    var        AssemblyLine: Record "Assembly Line";    begin        AssemblyLine.SetRange("Document No.", AssemblyHeaderNo);        AssemblyLine.DeleteAll();    end;    procedure DeleteAssemblyListComponent(ComponentType: Enum "BOM Component Type"; ParentItemNo: Code[20])    var        BOMComponent: Record "BOM Component";    begin        BOMComponent.SetRange("Parent Item No.", ParentItemNo);        BOMComponent.SetRange(Type, ComponentType);        if not BOMComponent.FindSet() then            exit;        BOMComponent.Next(LibraryRandom.RandInt(BOMComponent.Count));        BOMComponent.Delete();    end;    procedure DeleteAssemblyList(ParentItemNo: Code[20])    var        BOMComponent: Record "BOM Component";    begin        BOMComponent.SetRange("Parent Item No.", ParentItemNo);        BOMComponent.DeleteAll();    end;    procedure EditAssemblyListComponent(ComponentType: Enum "BOM Component Type"; NewComponentType: Enum "BOM Component Type"; NewComponentNo: Code[20]; ParentItemNo: Code[20]; ResourceUsage: Option; Qty: Decimal; UseBaseUnitOfMeasure: Boolean)    var        BOMComponent: Record "BOM Component";    begin        BOMComponent.SetRange("Parent Item No.", ParentItemNo);        BOMComponent.SetRange(Type, ComponentType);        if not BOMComponent.FindSet() then            exit;        BOMComponent.Next(LibraryRandom.RandInt(BOMComponent.Count));        if NewComponentNo <> '' then begin            BOMComponent.Validate(Type, NewComponentType);            BOMComponent.Validate("No.", NewComponentNo);            BOMComponent.Validate("Unit of Measure Code", GetUnitOfMeasureCode(NewComponentType, NewComponentNo, UseBaseUnitOfMeasure));        end else            BOMComponent.Validate("Unit of Measure Code", GetUnitOfMeasureCode(BOMComponent.Type, BOMComponent."No.", UseBaseUnitOfMeasure));        if ComponentType = BOMComponent.Type::Resource then            BOMComponent.Validate("Resource Usage Type", ResourceUsage);        BOMComponent.Validate("Quantity per", Qty);        BOMComponent.Validate(          Description, LibraryUtility.GenerateRandomCode(BOMComponent.FieldNo(Description), DATABASE::"BOM Component"));        BOMComponent.Modify(true);    end;    procedure EditAssemblyList(ChangeType: Option " ",Add,Replace,Delete,Edit,"Delete all","Edit cards"; ComponentType: Enum "BOM Component Type"; NewComponentType: Enum "BOM Component Type"; NewComponentNo: Code[20]; ParentItemNo: Code[20])    var        BOMComponent: Record "BOM Component";    begin        case ChangeType of            ChangeType::Add:                CreateAssemblyListComponent(                  NewComponentType, NewComponentNo, ParentItemNo, '', BOMComponent."Resource Usage Type"::Direct,                  LibraryRandom.RandDec(20, 2), true);            ChangeType::Replace:                EditAssemblyListComponent(                  ComponentType, NewComponentType, NewComponentNo, ParentItemNo, BOMComponent."Resource Usage Type"::Direct,                  LibraryRandom.RandDec(20, 2), true);            ChangeType::Delete:                DeleteAssemblyListComponent(ComponentType, ParentItemNo);            ChangeType::Edit:                EditAssemblyListComponent(                  ComponentType, NewComponentType, '', ParentItemNo, BOMComponent."Resource Usage Type"::Direct,                  LibraryRandom.RandDec(20, 2), false);            ChangeType::"Delete all":                DeleteAssemblyList(ParentItemNo);            ChangeType::"Edit cards":                ModifyCostParams(ParentItemNo, false, 0, 0);        end;    end;    procedure EditAssemblyLine(ComponentType: Enum "BOM Component Type"; NewComponentType: Enum "BOM Component Type"; NewComponentNo: Code[20]; AssemblyHeaderNo: Code[20]; Qty: Decimal; UseBaseUnitOfMeasure: Boolean)    var        AssemblyLine: Record "Assembly Line";    begin        AssemblyLine.SetCurrentKey("Document Type", "Document No.", Type);        AssemblyLine.SetRange("Document Type", AssemblyLine."Document Type"::Order);        AssemblyLine.SetRange("Document No.", AssemblyHeaderNo);        AssemblyLine.SetRange(Type, ComponentType);        if not AssemblyLine.FindSet() then            exit;        AssemblyLine.Next(LibraryRandom.RandInt(AssemblyLine.Count));        if AssemblyLine.Type = AssemblyLine.Type::Item then            AssemblyLine.Validate("Variant Code", LibraryInventory.GetVariant(AssemblyLine."No.", AssemblyLine."Variant Code"));        AssemblyLine.Validate(Description,          LibraryUtility.GenerateRandomCode(AssemblyLine.FieldNo(Description), DATABASE::"Assembly Line"));        AssemblyLine.Validate("Quantity per", Qty);        if NewComponentNo <> '' then begin            AssemblyLine.Validate(Type, NewComponentType);            AssemblyLine.Validate("No.", NewComponentNo);            AssemblyLine.Validate("Unit of Measure Code", GetUnitOfMeasureCode(NewComponentType, NewComponentNo, UseBaseUnitOfMeasure));        end else            AssemblyLine.Validate("Unit of Measure Code",              GetUnitOfMeasureCode(AssemblyLine.Type, AssemblyLine."No.", UseBaseUnitOfMeasure));        AssemblyLine.Modify(true);    end;    procedure EditAssemblyLines(ChangeType: Option " ",Add,Replace,Delete,Edit,"Delete all","Edit cards",Usage; ComponentType: Enum "BOM Component Type"; NewComponentType: Enum "BOM Component Type"; NewComponentNo: Code[20]; AssemblyHeaderNo: Code[20]; UseBaseUnitOfMeasure: Boolean)    var        AssemblyHeader: Record "Assembly Header";        AssemblyLine: Record "Assembly Line";    begin        AssemblyHeader.Get(AssemblyHeader."Document Type"::Order, AssemblyHeaderNo);        case ChangeType of            ChangeType::Add:                CreateAssemblyLine(AssemblyHeader, AssemblyLine, NewComponentType, NewComponentNo,                  GetUnitOfMeasureCode(NewComponentType, NewComponentNo, true), AssemblyHeader.Quantity, 1, '');            ChangeType::Replace:                EditAssemblyLine(                  ComponentType, NewComponentType, NewComponentNo, AssemblyHeaderNo, LibraryRandom.RandDec(20, 2),                  UseBaseUnitOfMeasure);            ChangeType::Delete:                DeleteAssemblyLine(ComponentType, AssemblyHeaderNo);            ChangeType::Edit:                EditAssemblyLine(                  ComponentType, NewComponentType, '', AssemblyHeaderNo, LibraryRandom.RandDec(20, 2), UseBaseUnitOfMeasure);            ChangeType::"Delete all":                DeleteAssemblyLines(AssemblyHeaderNo);            ChangeType::"Edit cards":                ModifyCostParams(AssemblyHeaderNo, false, 0, 0);            ChangeType::Usage:                ChangeResourceUsage(AssemblyHeaderNo);        end;        Commit();    end;    procedure EditOrderDimensions(AssemblyHeader: Record "Assembly Header")    var        TempDimension: Record Dimension temporary;        TempDimensionValue: Record "Dimension Value" temporary;    begin        CreateDimensionSetup(TempDimension, TempDimensionValue);        AssemblyHeader.Validate("Dimension Set ID",          LibraryDimension.CreateDimSet(AssemblyHeader."Dimension Set ID", TempDimension.Code, TempDimensionValue.Code));    end;    local procedure FindHeaderValueEntries(var ValueEntry: Record "Value Entry"; PostedAssemblyHeader: Record "Posted Assembly Header"; EntryType: Enum "Cost Entry Type"; ItemLedgerEntryType: Enum "Item Ledger Entry Type")    begin        ValueEntry.Reset();        ValueEntry.SetRange("Item No.", PostedAssemblyHeader."Item No.");        ValueEntry.SetRange("Item Ledger Entry Type", ItemLedgerEntryType);        ValueEntry.SetRange("Entry Type", EntryType);        ValueEntry.SetRange("Document No.", PostedAssemblyHeader."No.");        ValueEntry.SetRange("Location Code", PostedAssemblyHeader."Location Code");        ValueEntry.SetRange("Variant Code", PostedAssemblyHeader."Variant Code");        ValueEntry.SetRange("Inventory Posting Group", PostedAssemblyHeader."Inventory Posting Group");        ValueEntry.SetRange("Gen. Prod. Posting Group", PostedAssemblyHeader."Gen. Prod. Posting Group");        ValueEntry.SetRange("Item Ledger Entry Quantity", 0);        ValueEntry.SetRange("Invoiced Quantity", 0);        ValueEntry.SetRange("Valued Quantity", PostedAssemblyHeader.Quantity);        ValueEntry.SetRange("Order Type", ValueEntry."Order Type"::Assembly);        ValueEntry.SetRange("Order No.", PostedAssemblyHeader."Order No.");        ValueEntry.SetRange("Order Line No.", 0);    end;    local procedure FindLineValueEntries(var ValueEntry: Record "Value Entry"; PostedAssemblyLine: Record "Posted Assembly Line"; EntryType: Enum "Cost Entry Type"; ItemLedgerEntryType: Enum "Item Ledger Entry Type")    begin        ValueEntry.Reset();        if PostedAssemblyLine.Type = PostedAssemblyLine.Type::Item then            ValueEntry.SetRange("Item No.", PostedAssemblyLine."No.")        else begin            ValueEntry.SetRange(Type, ValueEntry.Type::Resource);            ValueEntry.SetRange("No.", PostedAssemblyLine."No.");        end;        ValueEntry.SetRange("Item Ledger Entry Type", ItemLedgerEntryType);        ValueEntry.SetRange("Entry Type", EntryType);        ValueEntry.SetRange("Document No.", PostedAssemblyLine."Document No.");        ValueEntry.SetRange("Location Code", PostedAssemblyLine."Location Code");        ValueEntry.SetRange("Variant Code", PostedAssemblyLine."Variant Code");        if ItemLedgerEntryType = "Item Ledger Entry Type"::"Assembly Consumption" then            ValueEntry.SetRange("Valued Quantity", -PostedAssemblyLine.Quantity)        else            ValueEntry.SetRange("Valued Quantity", PostedAssemblyLine.Quantity);        ValueEntry.SetRange("Order Type", ValueEntry."Order Type"::Assembly);        ValueEntry.SetRange("Order No.", PostedAssemblyLine."Order No.");        ValueEntry.SetRange("Order Line No.", PostedAssemblyLine."Order Line No.");    end;    procedure FindLinkedAssemblyOrder(var AssemblyHeader: Record "Assembly Header"; DocumentType: Enum "Sales Document Type"; DocumentNo: Code[20]; DocumentLineNo: Integer)    var        AssembleToOrderLink: Record "Assemble-to-Order Link";    begin        AssembleToOrderLink.SetRange(Type, AssembleToOrderLink.Type::Sale);        AssembleToOrderLink.SetRange("Document Type", DocumentType);        AssembleToOrderLink.SetRange("Document No.", DocumentNo);        AssembleToOrderLink.SetRange("Document Line No.", DocumentLineNo);        AssembleToOrderLink.FindFirst();        AssemblyHeader.Get(AssembleToOrderLink."Assembly Document Type", AssembleToOrderLink."Assembly Document No.");    end;    procedure FindPostedAssemblyLines(var PostedAssemblyLine: Record "Posted Assembly Line"; PostedAssemblyHeader: Record "Posted Assembly Header")    begin        PostedAssemblyLine.Reset();        PostedAssemblyLine.SetRange("Document No.", PostedAssemblyHeader."No.");        PostedAssemblyLine.SetRange("Order No.", PostedAssemblyHeader."Order No.");        PostedAssemblyLine.SetRange(Type, PostedAssemblyLine.Type::Item);    end;    procedure FindPostedAssemblyHeaders(var PostedAssemblyHeader: Record "Posted Assembly Header"; AssemblyHeader: Record "Assembly Header")    begin        PostedAssemblyHeader.Reset();        PostedAssemblyHeader.SetRange("Order No.", AssemblyHeader."No.");        PostedAssemblyHeader.SetRange("Item No.", AssemblyHeader."Item No.");    end;    procedure GetBOMComponentLines(var TempBOMComponent: Record "BOM Component" temporary; ParentItemNo: Code[20])    var        BOMComponent: Record "BOM Component";        Item: Record Item;    begin        BOMComponent.SetRange("Parent Item No.", ParentItemNo);        BOMComponent.SetRange(Type, BOMComponent.Type::Item);        if BOMComponent.FindSet() then            repeat                Item.Get(BOMComponent."No.");                if Item."Assembly BOM" then                    GetBOMComponentLines(TempBOMComponent, Item."No.")                else begin                    TempBOMComponent := BOMComponent;                    TempBOMComponent.Insert();                end;            until BOMComponent.Next() = 0;        BOMComponent.SetRange(Type, BOMComponent.Type::Resource);        if BOMComponent.FindSet() then            repeat                TempBOMComponent := BOMComponent;                TempBOMComponent.Insert();            until BOMComponent.Next() = 0;    end;    procedure GetCostInformation(var UnitCost: Decimal; var Overhead: Decimal; var IndirectCost: Decimal; Type: Enum "BOM Component Type"; No: Code[20]; VariantCode: Code[10]; LocationCode: Code[10]): Boolean    var        Resource: Record Resource;        Item: Record Item;        StockkeepingUnit: Record "Stockkeeping Unit";    begin        case Type of            "BOM Component Type"::Item:                begin                    Item.Get(No);                    StockkeepingUnit.SetCurrentKey("Location Code", "Item No.", "Variant Code");                    if StockkeepingUnit.Get(LocationCode, Item."No.", VariantCode) then                        UnitCost := StockkeepingUnit."Unit Cost"                    else                        UnitCost := Item."Unit Cost";                    Overhead := Item."Overhead Rate";                    IndirectCost := Item."Indirect Cost %";                    exit(Item."Cost is Adjusted");                end;            "BOM Component Type"::Resource:                begin                    Resource.Get(No);                    UnitCost := Resource."Unit Cost";                    Overhead := Resource."Unit Cost" - Resource."Direct Unit Cost";                    IndirectCost := Resource."Indirect Cost %";                    exit(false);                end;        end;    end;    procedure GetUnitOfMeasureCode(ComponentType: Enum "BOM Component Type"; ComponentNo: Code[20]; UseBaseUnitOfMeasure: Boolean): Code[10]    var        Item: Record Item;        Resource: Record Resource;        ItemUnitOfMeasure: Record "Item Unit of Measure";        ResourceUnitOfMeasure: Record "Resource Unit of Measure";        BOMComponent: Record "BOM Component";    begin        case ComponentType of            BOMComponent.Type::Item:                begin                    Item.Get(ComponentNo);                    if UseBaseUnitOfMeasure then                        exit(Item."Base Unit of Measure");                    ItemUnitOfMeasure.SetRange("Item No.", Item."No.");                    ItemUnitOfMeasure.SetFilter(Code, '<>%1', Item."Base Unit of Measure");                    if ItemUnitOfMeasure.FindFirst() then                        exit(ItemUnitOfMeasure.Code);                end;            BOMComponent.Type::Resource:                begin                    Resource.Get(ComponentNo);                    if UseBaseUnitOfMeasure then                        exit(Resource."Base Unit of Measure");                    ResourceUnitOfMeasure.SetRange("Resource No.", Resource."No.");                    ResourceUnitOfMeasure.SetFilter(Code, '<>%1', Resource."Base Unit of Measure");                    if ResourceUnitOfMeasure.FindFirst() then                        exit(ResourceUnitOfMeasure.Code);                end        end;        exit('');    end;    procedure GetAdjAmounts(var VarianceAmount: Decimal; var AdjAmount: Decimal; PostedAssemblyHeader: Record "Posted Assembly Header")    var        ValueEntry: Record "Value Entry";        DirectCostAmount: Decimal;        OutputNotAdjAmount: Decimal;    begin        ValueEntry.Reset();        ValueEntry.SetRange("Document No.", PostedAssemblyHeader."No.");        ValueEntry.SetRange("Order Type", ValueEntry."Order Type"::Assembly);        ValueEntry.SetRange("Order No.", PostedAssemblyHeader."Order No.");        ValueEntry.SetRange("Entry Type", ValueEntry."Entry Type"::"Direct Cost");        DirectCostAmount := 0;        OutputNotAdjAmount := 0;        if ValueEntry.FindSet() then            repeat                case ValueEntry."Item Ledger Entry Type" of                    ValueEntry."Item Ledger Entry Type"::" ":                        DirectCostAmount += -ValueEntry."Cost Amount (Actual)";                    ValueEntry."Item Ledger Entry Type"::"Assembly Consumption":                        DirectCostAmount += ValueEntry."Cost Amount (Actual)";                    ValueEntry."Item Ledger Entry Type"::"Assembly Output":                        if not ValueEntry.Adjustment then                            OutputNotAdjAmount += ValueEntry."Cost Amount (Actual)";                end;            until ValueEntry.Next() = 0;        AdjAmount := DirectCostAmount + OutputNotAdjAmount;        VarianceAmount := DirectCostAmount + PostedAssemblyHeader."Cost Amount";    end;    procedure GetCompsToAdjust(var ItemNo: array[10] of Code[20]; var ResourceNo: array[10] of Code[20]; AssemblyHeader: Record "Assembly Header"): Text[250]    var        AssemblyLine: Record "Assembly Line";        ItemFilter: Text[250];        i: Integer;    begin        AssemblyLine.SetRange("Document Type", AssemblyHeader."Document Type");        AssemblyLine.SetRange("Document No.", AssemblyHeader."No.");        AssemblyLine.SetRange(Type, AssemblyLine.Type::Item);        ItemFilter := AssemblyHeader."Item No.";        i := 1;        if AssemblyLine.FindSet() then            repeat                ItemNo[i] := AssemblyLine."No.";                ItemFilter += '|' + ItemNo[i];                i += 1;            until AssemblyLine.Next() = 0;        ItemFilter := DelChr(ItemFilter, '>', '|');        i := 1;        AssemblyLine.SetRange(Type, AssemblyLine.Type::Resource);        if AssemblyLine.FindSet() then            repeat                ResourceNo[i] := AssemblyLine."No.";                i += 1;            until AssemblyLine.Next() = 0;        exit(ItemFilter)    end;    local procedure GetValueEntriesAmount(PostedAssemblyHeader: Record "Posted Assembly Header"; ItemLedgerEntryType: Enum "Item Ledger Entry Type"; EntryType: Enum "Cost Entry Type"; VarianceType: Enum "Cost Variance Type"; ItemNo: Code[20]; PostedToGL: Boolean): Decimal    var        ValueEntry: Record "Value Entry";        Amount: Decimal;    begin        ValueEntry.Reset();        ValueEntry.SetRange("Document No.", PostedAssemblyHeader."No.");        ValueEntry.SetRange("Order Type", ValueEntry."Order Type"::Assembly);        ValueEntry.SetRange("Order No.", PostedAssemblyHeader."Order No.");        ValueEntry.SetRange("Item Ledger Entry Type", ItemLedgerEntryType);        ValueEntry.SetRange("Variance Type", VarianceType);        ValueEntry.SetRange("Entry Type", EntryType);        if ItemNo <> '' then            ValueEntry.SetRange("Item No.", ItemNo);        if PostedToGL then            ValueEntry.SetFilter("Cost Posted to G/L", '<>%1', 0);        Amount := 0;        if ValueEntry.FindSet() then            repeat                Amount += ValueEntry."Cost Amount (Actual)";            until ValueEntry.Next() = 0;        exit(Amount);    end;    procedure GetPostingSetup(var GeneralPostingSetup: Record "General Posting Setup"; var InventoryPostingSetup: Record "Inventory Posting Setup"; GenProdPostingGr: Code[20]; InvtPostingGroup: Code[20]; LocationCode: Code[10])    begin        GeneralPostingSetup.Get('', GenProdPostingGr);        InventoryPostingSetup.Get(LocationCode, InvtPostingGroup);    end;    procedure ModifyCostParams(ParentItemNo: Code[20]; CostAdjNeeded: Boolean; IndirectCost: Decimal; Overhead: Decimal)    var        Resource: Record Resource;        BOMComponent: Record "BOM Component";    begin        BOMComponent.SetRange("Parent Item No.", ParentItemNo);        if BOMComponent.FindSet() then            repeat                case BOMComponent.Type of                    BOMComponent.Type::Item:                        ModifyItem(BOMComponent."No.", CostAdjNeeded, IndirectCost, Overhead);                    BOMComponent.Type::Resource:                        begin                            Resource.Get(BOMComponent."No.");                            Resource.Validate("Unit Price", Resource."Unit Price" + LibraryRandom.RandDec(10, 2));                            if CostAdjNeeded then begin                                Resource.Validate("Direct Unit Cost", Resource."Direct Unit Cost" + LibraryRandom.RandDec(10, 2));                                Resource.Validate("Indirect Cost %", IndirectCost);                            end;                            Resource.Modify(true);                        end                end;            until BOMComponent.Next() = 0;    end;    procedure ModifyItem(ItemNo: Code[20]; CostAdjNeeded: Boolean; IndirectCost: Decimal; Overhead: Decimal)    var        Item: Record Item;    begin        Item.Get(ItemNo);        if CostAdjNeeded then begin            Item.Validate("Indirect Cost %", IndirectCost);            Item.Validate("Overhead Rate", Overhead);            if Item."Costing Method" = Item."Costing Method"::Standard then                Item.Validate("Standard Cost", Item."Standard Cost" + LibraryRandom.RandDec(10, 2))            else                Item.Validate("Unit Cost", Item."Unit Cost" + LibraryRandom.RandDec(10, 2));        end;        Item.Validate("Unit Price", Item."Unit Price" + LibraryRandom.RandDec(10, 2));        Item.Validate("Lot Size", Item."Lot Size" + LibraryRandom.RandInt(10));        Item.Modify(true);    end;    procedure ModifyOrderCostParams(AssemblyHeaderNo: Code[20]; CostAdjNeeded: Boolean; IndirectCost: Decimal; Overhead: Decimal)    var        Resource: Record Resource;        AssemblyLine: Record "Assembly Line";    begin        AssemblyLine.SetRange("Document Type", AssemblyLine."Document Type"::Order);        AssemblyLine.SetRange("Document No.", AssemblyHeaderNo);        if AssemblyLine.FindSet() then            repeat                case AssemblyLine.Type of                    AssemblyLine.Type::Item:                        ModifyItem(AssemblyLine."No.", CostAdjNeeded, IndirectCost, Overhead);                    AssemblyLine.Type::Resource:                        begin                            Resource.Get(AssemblyLine."No.");                            Resource.Validate("Indirect Cost %", IndirectCost);                            Resource.Validate("Unit Price", Resource."Unit Price" + LibraryRandom.RandDec(10, 2));                            Resource.Validate("Unit Cost", Resource."Unit Cost" + LibraryRandom.RandDec(10, 2));                            Resource.Modify(true);                        end                end;            until AssemblyLine.Next() = 0;    end;    procedure NeedsAdjustment(var AdjUnitCost: Decimal; Item: Record Item; PostedAssemblyLine: Record "Posted Assembly Line"; FinalAdjSource: Option; UnitCost: Decimal): Boolean    begin        if FinalAdjSource = AdjSource::Revaluation then            AdjUnitCost := GetDirectUnitCost(Item."No.") - PostedAssemblyLine."Unit Cost"        else            AdjUnitCost := GetInboundItemCost(Item."No.") - PostedAssemblyLine."Unit Cost";        exit(            Item."Cost is Adjusted" and            (Abs(AdjUnitCost) > LibraryERM.GetAmountRoundingPrecision()) and            (Abs(AdjUnitCost * PostedAssemblyLine.Quantity) >= LibraryERM.GetAmountRoundingPrecision())        );    end;    local procedure GetInboundItemCost(ItemNo: Code[20]): Decimal    var        ItemLedgerEntry: Record "Item Ledger Entry";    begin        ItemLedgerEntry.SetRange("Item No.", ItemNo);        ItemLedgerEntry.SetRange("Entry Type", ItemLedgerEntry."Entry Type"::"Positive Adjmt.");        ItemLedgerEntry.SetLoadFields(Quantity, "Cost Amount (Actual)", "Remaining Quantity");        ItemLedgerEntry.SetAutoCalcFields("Cost Amount (Actual)");        ItemLedgerEntry.FindFirst();        exit(ItemLedgerEntry.GetUnitCostLCY());    end;    local procedure GetDirectUnitCost(ItemNo: Code[20]): Decimal    var        ValueEntry: Record "Value Entry";    begin        ValueEntry.SetRange("Item No.", ItemNo);        ValueEntry.SetRange("Entry Type", ValueEntry."Item Ledger Entry Type"::"Positive Adjmt.");        ValueEntry.SetRange("Entry Type", ValueEntry."Entry Type"::"Direct Cost");        ValueEntry.SetLoadFields("Cost per Unit");        ValueEntry.FindFirst();        exit(ValueEntry."Cost per Unit");    end;    procedure PostAssemblyHeader(AssemblyHeader: Record "Assembly Header"; ExpectedError: Text[1024])    var        AssemblyPost: Codeunit "Assembly-Post";    begin        if ExpectedError = '' then            AssemblyPost.Run(AssemblyHeader)        else begin            #pragma warning disable AS0058, PTE0007 // Accepted violation: this is a test library helper that intentionally wraps asserterror for use by test codeunits.            asserterror AssemblyPost.Run(AssemblyHeader);            #pragma warning restore AS0058, PTE0007            Assert.IsTrue(StrPos(GetLastErrorText, ExpectedError) > 0,              'Expected:' + ExpectedError + '. Actual:' + GetLastErrorText);            ClearLastError();        end;        Commit();    end;    procedure PrepareOrderPosting(var AssemblyHeader: Record "Assembly Header"; var TempAssemblyLine: Record "Assembly Line" temporary; HeaderQtyFactor: Integer; CompQtyFactor: Integer; UpdateAllComps: Boolean; PostingDate: Date)    var        AssemblyLine: Record "Assembly Line";    begin        TempAssemblyLine.DeleteAll();        AssemblyHeader.Validate("Quantity to Assemble", AssemblyHeader."Quantity to Assemble" * HeaderQtyFactor / 100);        AssemblyHeader.Validate(Description,          LibraryUtility.GenerateRandomCode(AssemblyHeader.FieldNo(Description), DATABASE::"Assembly Header"));        AssemblyHeader.Validate("Posting Date", PostingDate);        AddAssemblyHeaderComment(AssemblyHeader, 0);        AssemblyHeader.Modify(true);        AssemblyLine.SetRange("Document Type", AssemblyHeader."Document Type");        AssemblyLine.SetRange("Document No.", AssemblyHeader."No.");        if AssemblyLine.FindSet() then            repeat                AssemblyLine.Validate("Quantity to Consume", AssemblyLine.Quantity * CompQtyFactor / 100);                AssemblyLine.Validate(Description,                  LibraryUtility.GenerateRandomCode(AssemblyLine.FieldNo(Description), DATABASE::"Assembly Line"));                AddAssemblyHeaderComment(AssemblyHeader, AssemblyLine."Line No.");                AssemblyLine.Modify(true);                if AssemblyLine."Quantity to Consume" > 0 then begin                    TempAssemblyLine := AssemblyLine;                    TempAssemblyLine.Insert();                end;            until (AssemblyLine.Next() = 0) or (not UpdateAllComps);    end;    procedure ReopenAO(var AssemblyHeader: Record "Assembly Header")    var        ReleaseAssemblyDoc: Codeunit "Release Assembly Document";    begin        ReleaseAssemblyDoc.Reopen(AssemblyHeader);    end;    procedure ReleaseAO(var AssemblyHeader: Record "Assembly Header")    begin        CODEUNIT.Run(CODEUNIT::"Release Assembly Document", AssemblyHeader);    end;    procedure RevaluateItem(var Item: Record Item; var ItemJournalLine: Record "Item Journal Line"; OldUnitCost: Decimal; PostingDate: Date)    var        ItemJournalTemplate: Record "Item Journal Template";        ItemJournalBatch: Record "Item Journal Batch";    begin        LibraryInventory.SelectItemJournalTemplateName(ItemJournalTemplate, ItemJournalTemplate.Type::Revaluation);        LibraryInventory.SelectItemJournalBatchName(ItemJournalBatch, ItemJournalTemplate.Type::Revaluation, ItemJournalTemplate.Name);        LibraryInventory.CreateItemJournalLine(ItemJournalLine, ItemJournalBatch."Journal Template Name", ItemJournalBatch.Name,          ItemJournalLine."Entry Type"::Purchase, Item."No.", 0);        Item.SetRange("No.", Item."No.");        LibraryCosting.CreateRevaluationJnlLines(            Item, ItemJournalLine, ItemJournalLine."Document No.", "Inventory Value Calc. Per"::Item,            "Inventory Value Calc. Base"::" ", true, true, true, PostingDate);        ItemJournalLine.Reset();        ItemJournalLine.SetRange("Journal Template Name", ItemJournalLine."Journal Template Name");        ItemJournalLine.SetRange("Journal Batch Name", ItemJournalLine."Journal Batch Name");        ItemJournalLine.SetRange("Item No.", Item."No.");        ItemJournalLine.FindFirst();        ItemJournalLine.Validate("Unit Cost (Revalued)", OldUnitCost + LibraryRandom.RandInt(50));        ItemJournalLine.Modify(true);    end;    procedure RollUpAsmCost(var SalesLine: Record "Sales Line")    begin        SalesLine.RollUpAsmCost();    end;    procedure RollUpAsmPrice(var SalesLine: Record "Sales Line")    begin        SalesLine.RollupAsmPrice();    end;    procedure SetupComponents(var TempItem: Record Item temporary; var TempResource: Record Resource temporary; CostingMethod: Enum "Costing Method"; NoOfItems: Integer; NoOfResources: Integer; GenProdPostingGroup: Code[20]; InventoryPostingGroup: Code[20])    var        Item: Record Item;        Resource: Record Resource;        AssemblyLine: Record "Assembly Line";        CompCount: Integer;    begin        TempItem.DeleteAll();        TempResource.DeleteAll();        for CompCount := 1 to NoOfItems do begin            Clear(Item);            CreateItem(Item, CostingMethod, Item."Replenishment System"::Purchase, GenProdPostingGroup, InventoryPostingGroup);            AddEntityDimensions(AssemblyLine.Type::Item, Item."No.");            TempItem := Item;            TempItem.Insert();        end;        for CompCount := 1 to NoOfResources do begin            CreateResource(Resource, true, GenProdPostingGroup);            AddEntityDimensions(AssemblyLine.Type::Resource, Resource."No.");            TempResource := Resource;            TempResource.Insert();        end;    end;    procedure CreateAssemblyOrder(var AssemblyHeader: Record "Assembly Header"; DueDate: Date; LocationCode: Code[10]; NoOfItems: Integer)    var        Item: Record Item;    begin        SetupAssemblyItem(          Item, Item."Costing Method"::Standard, Item."Costing Method"::Standard, Item."Replenishment System"::Assembly, LocationCode, false,          NoOfItems,          LibraryRandom.RandIntInRange(1, 3),          LibraryRandom.RandIntInRange(1, 3),          LibraryRandom.RandIntInRange(1, 10));        CreateAssemblyHeader(AssemblyHeader, DueDate, Item."No.", LocationCode, LibraryRandom.RandDec(10, 2), '');    end;    procedure SetStockoutWarning(StockoutWarning: Boolean)    var        AssemblySetup: Record "Assembly Setup";    begin        AssemblySetup.Get();        AssemblySetup.Validate("Stockout Warning", StockoutWarning);        AssemblySetup.Modify(true);    end;    procedure SetupAssemblyData(var AssemblyHeader: Record "Assembly Header"; DueDate: Date; ParentCostingMethod: Enum "Costing Method"; CompCostingMethod: Enum "Costing Method"; ReplenishmentSystem: Enum "Replenishment System"; LocationCode: Code[10]; UpdateUnitCost: Boolean)    var        Item: Record Item;    begin        SetupAssemblyItem(Item, ParentCostingMethod, CompCostingMethod, ReplenishmentSystem, LocationCode, UpdateUnitCost, 1, 1, 1, 1);        CreateAssemblyHeader(AssemblyHeader, DueDate, Item."No.", LocationCode, LibraryRandom.RandDec(10, 2), '');    end;    procedure SetupAssemblyItem(var Item: Record Item; ParentCostingMethod: Enum "Costing Method"; CompCostingMethod: Enum "Costing Method"; ReplenishmentSystem: Enum "Replenishment System"; LocationCode: Code[10]; UpdateUnitCost: Boolean; NoOfItems: Integer; NoOfResources: Integer; NoOfTexts: Integer; QtyPerFactor: Integer)    var        AssemblyLine: Record "Assembly Line";        CalculateStandardCost: Codeunit "Calculate Standard Cost";        GenProdPostingGr: Code[20];        AsmInvtPostingGr: Code[20];        CompInvtPostingGr: Code[20];    begin        SetupPostingToGL(GenProdPostingGr, AsmInvtPostingGr, CompInvtPostingGr, LocationCode);        CreateItem(Item, ParentCostingMethod, ReplenishmentSystem, GenProdPostingGr, AsmInvtPostingGr);        AddEntityDimensions(AssemblyLine.Type::Item, Item."No.");        CreateAssemblyList(          CompCostingMethod, Item."No.", true, NoOfItems, NoOfResources, NoOfTexts, QtyPerFactor, GenProdPostingGr, CompInvtPostingGr);        if UpdateUnitCost then begin            CalculateStandardCost.CalcItem(Item."No.", true);            CalculateStandardCost.CalcAssemblyItemPrice(Item."No.");        end;    end;    procedure SetupItemJournal(var ItemJournalTemplate: Record "Item Journal Template"; var ItemJournalBatch: Record "Item Journal Batch")    var        NoSeries: Record "No. Series";        NoSeriesLine: Record "No. Series Line";    begin        Clear(ItemJournalTemplate);        ItemJournalTemplate.Init();        LibraryInventory.SelectItemJournalTemplateName(ItemJournalTemplate, ItemJournalTemplate.Type::Item);        Clear(ItemJournalBatch);        ItemJournalBatch.Init();        LibraryInventory.SelectItemJournalBatchName(ItemJournalBatch, ItemJournalTemplate.Type, ItemJournalTemplate.Name);        if ItemJournalBatch."No. Series" = '' then begin            LibraryUtility.CreateNoSeries(NoSeries, true, true, true);            LibraryUtility.CreateNoSeriesLine(NoSeriesLine, NoSeries.Code, '', '');            ItemJournalBatch.Validate("No. Series", NoSeries.Code);            ItemJournalBatch.Modify(true);        end;    end;    procedure SetupPostingToGL(var GenProdPostingGr: Code[20]; var AsmInvtPostingGr: Code[20]; var CompInvtPostingGr: Code[20]; LocationCode: Code[10])    var        InventoryPostingGroup: Record "Inventory Posting Group";        GLAccount: Record "G/L Account";        GLAccount2: Record "G/L Account";        GLAccount3: Record "G/L Account";        GLAccount4: Record "G/L Account";        GLAccount5: Record "G/L Account";        GLAccount6: Record "G/L Account";        GeneralPostingSetup: Record "General Posting Setup";        InvtPostingSetup: Record "Inventory Posting Setup";    begin        // Create Inventory posting setup accounts.        // Assembly Item Inventory.        CreateGLAccount(GLAccount, GLAccount."Income/Balance"::"Balance Sheet", 'Output Inventory');        // Material Variance.        CreateGLAccount(GLAccount2, GLAccount."Income/Balance"::"Income Statement", 'Material Variance');        // Capacity Variance.        CreateGLAccount(GLAccount3, GLAccount."Income/Balance"::"Income Statement", 'Capacity Variance');        // Capacity Overhead Variance.        CreateGLAccount(GLAccount4, GLAccount."Income/Balance"::"Income Statement", 'Capacity Overhead Variance');        // Mfg. Overhead Variance.        CreateGLAccount(GLAccount5, GLAccount."Income/Balance"::"Income Statement", 'Mfg. Overhead Variance');        // Inventory account (Interim)        CreateGLAccount(GLAccount6, GLAccount."Income/Balance"::"Balance Sheet", 'Inventory Account (Interim)');        // Create Inventory Posting Group for Assembly Item.        LibraryInventory.CreateInventoryPostingGroup(InventoryPostingGroup);        AsmInvtPostingGr := InventoryPostingGroup.Code;        // Create Inventory Posting Setup for Assembly Item.        CreateInvtPostingSetup(InvtPostingSetup, LocationCode, InventoryPostingGroup.Code, GLAccount."No.", GLAccount2."No.",          GLAccount3."No.", GLAccount4."No.", GLAccount5."No.", GLAccount6."No.");        // Component Inventory Account.        CreateGLAccount(GLAccount, GLAccount."Income/Balance"::"Balance Sheet", 'Component Item Inventory');        // Create Inventory Posting Group for Component.        LibraryInventory.CreateInventoryPostingGroup(InventoryPostingGroup);        CompInvtPostingGr := InventoryPostingGroup.Code;        // Create Inventory Posting Setup for Assembly Item.        CreateInvtPostingSetup(InvtPostingSetup, LocationCode, InventoryPostingGroup.Code, GLAccount."No.", GLAccount2."No.",          GLAccount3."No.", GLAccount4."No.", GLAccount5."No.", GLAccount6."No.");        LibraryERM.FindGeneralPostingSetupInvtToGL(GeneralPostingSetup);        GenProdPostingGr := GeneralPostingSetup."Gen. Prod. Posting Group";    end;    procedure UndoPostedAssembly(var PostedAssemblyHeader: Record "Posted Assembly Header"; RestoreAO: Boolean; ExpectedError: Text[1024])    var        AsmPostCtrl: Codeunit "Assembly-Post";    begin        Clear(AsmPostCtrl);        if ExpectedError = '' then            AsmPostCtrl.Undo(PostedAssemblyHeader, RestoreAO)        else begin            #pragma warning disable AS0058, PTE0007 // Accepted violation: this is a test library helper that intentionally wraps asserterror for use by test codeunits.            asserterror AsmPostCtrl.Undo(PostedAssemblyHeader, RestoreAO);            #pragma warning restore AS0058, PTE0007            Assert.IsTrue(StrPos(GetLastErrorText, ExpectedError) > 0, 'Actual:' + GetLastErrorText);            ClearLastError();        end;    end;    procedure UpdateOrderCost(var AssemblyHeader: Record "Assembly Header")    var        Item: Record Item;    begin        Commit();        if AssemblyHeader.Quantity = 0 then begin            #pragma warning disable AS0058, PTE0007 // Accepted violation: this is a test library helper that intentionally wraps asserterror for use by test codeunits.            asserterror AssemblyHeader.UpdateUnitCost();            #pragma warning restore AS0058, PTE0007            Assert.AreEqual(              StrSubstNo(ErrorZeroQty, AssemblyHeader."No."), GetLastErrorText,              'Actual:' + GetLastErrorText + '; Expected:' + StrSubstNo(ErrorZeroQty, AssemblyHeader."No."));            ClearLastError();            exit;        end;        Item.Get(AssemblyHeader."Item No.");        if Item."Costing Method" <> Item."Costing Method"::Standard then            AssemblyHeader.UpdateUnitCost()        else begin            #pragma warning disable AS0058, PTE0007 // Accepted violation: this is a test library helper that intentionally wraps asserterror for use by test codeunits.            asserterror AssemblyHeader.UpdateUnitCost();            #pragma warning restore AS0058, PTE0007            Assert.IsTrue(StrPos(GetLastErrorText, ErrorStdCost) > 0, 'Actual:' + GetLastErrorText + '; Expected:' + ErrorStdCost);            ClearLastError();        end;        Commit();    end;    procedure UpdateAssemblySetup(var AssemblySetup: Record "Assembly Setup"; LocationCode: Code[10]; DimensionsFrom: Option; PostedOrdersNos: Code[20])    begin        AssemblySetup.Get();        if AssemblySetup."Assembly Order Nos." = '' then            AssemblySetup.Validate("Assembly Order Nos.", LibraryUtility.GetGlobalNoSeriesCode());        AssemblySetup.Validate("Copy Component Dimensions from", DimensionsFrom);        AssemblySetup.Validate("Default Location for Orders", LocationCode);        AssemblySetup.Validate("Posted Assembly Order Nos.", PostedOrdersNos);        AssemblySetup.Modify(true);    end;    procedure UpdateInventorySetup(var InventorySetup: Record "Inventory Setup"; AutomaticCostPosting: Boolean; ExpectedCostPostingtoGL: Boolean; AutomaticCostAdjustment: Enum "Automatic Cost Adjustment Type"; AverageCostCalcType: Enum "Average Cost Calculation Type"; AverageCostPeriod: Enum "Average Cost Period Type")    begin        InventorySetup.Get();        InventorySetup."Automatic Cost Posting" := AutomaticCostPosting;        InventorySetup."Expected Cost Posting to G/L" := ExpectedCostPostingtoGL;        InventorySetup."Automatic Cost Adjustment" := AutomaticCostAdjustment;        InventorySetup."Average Cost Calc. Type" := AverageCostCalcType;        InventorySetup."Average Cost Period" := AverageCostPeriod;        InventorySetup.Modify(true);    end;    procedure UpdateAssemblyLine(var AssemblyLine: Record "Assembly Line"; FieldNo: Integer; Value: Variant)    var        RecRef: RecordRef;        FieldRef: FieldRef;    begin        RecRef.GetTable(AssemblyLine);        FieldRef := RecRef.Field(FieldNo);        FieldRef.Validate(Value);        RecRef.SetTable(AssemblyLine);        AssemblyLine.Modify(true);    end;    procedure UpdateAssemblyHeader(var AssemblyHeader: Record "Assembly Header"; FieldNo: Integer; Value: Variant)    var        RecRef: RecordRef;        FieldRef: FieldRef;    begin        RecRef.GetTable(AssemblyHeader);        FieldRef := RecRef.Field(FieldNo);        FieldRef.Validate(Value);        RecRef.SetTable(AssemblyHeader);        AssemblyHeader.Modify(true);    end;    procedure UpdateInvtPeriod(var InventoryPeriod: Record "Inventory Period"; ReOpen: Boolean)    var        ItemLedgerEntry: Record "Item Ledger Entry";        CloseInventoryPeriod: Codeunit "Close Inventory Period";    begin        LibraryCosting.AdjustCostItemEntries('', '');        ItemLedgerEntry.SetRange(Open, true);        if ItemLedgerEntry.FindFirst() then            ItemLedgerEntry.Delete();        CloseInventoryPeriod.SetReOpen(ReOpen);        CloseInventoryPeriod.SetHideDialog(true);        CloseInventoryPeriod.Run(InventoryPeriod);        if ReOpen then            InventoryPeriod.Delete();    end;    procedure UpdateSKUCards(Item: Record Item)    var        StockkeepingUnit: Record "Stockkeeping Unit";    begin        StockkeepingUnit.SetRange("Item No.", Item."No.");        if StockkeepingUnit.FindSet() then            repeat                if Item."Costing Method" = Item."Costing Method"::Standard then                    StockkeepingUnit.Validate("Standard Cost", Item."Standard Cost" + LibraryRandom.RandDec(10, 2))                else                    StockkeepingUnit.Validate("Unit Cost", Item."Unit Cost" + LibraryRandom.RandDec(10, 2));                StockkeepingUnit.Modify(true);            until StockkeepingUnit.Next() = 0;    end;    procedure VerifytAsmReservationEntryATO(AssemblyHeader: Record "Assembly Header"): Integer    var        ReservationEntry: Record "Reservation Entry";    begin        Clear(ReservationEntry);        ReservationEntry.SetRange(Positive, true);        ReservationEntry.SetRange("Item No.", AssemblyHeader."Item No.");        ReservationEntry.SetRange(Description, AssemblyHeader.Description);        ReservationEntry.SetRange("Location Code", AssemblyHeader."Location Code");        ReservationEntry.SetRange("Reservation Status", ReservationEntry."Reservation Status"::Reservation);        ReservationEntry.SetRange("Source Type", DATABASE::"Assembly Header");        ReservationEntry.SetRange("Source Subtype", AssemblyHeader."Document Type");        ReservationEntry.SetRange("Source Ref. No.", 0);        ReservationEntry.SetRange("Source ID", AssemblyHeader."No.");        ReservationEntry.SetRange(Quantity, AssemblyHeader.Quantity);        ReservationEntry.SetRange(Binding, ReservationEntry.Binding::"Order-to-Order");        ReservationEntry.SetRange("Planning Flexibility", ReservationEntry."Planning Flexibility"::None);        ReservationEntry.SetRange("Shipment Date", AssemblyHeader."Due Date");        ReservationEntry.SetRange("Variant Code", AssemblyHeader."Variant Code");        ReservationEntry.SetRange("Disallow Cancellation", true);        Assert.AreEqual(1, ReservationEntry.Count, 'Couldn''t find the AO reservation entry with the filters: ' +          ReservationEntry.GetFilters);        exit(ReservationEntry."Entry No.");    end;    procedure VerifyHardLinkEntry(SalesLine: Record "Sales Line"; AssemblyHeader: Record "Assembly Header"; NoOfEntries: Integer)    var        ATOLink: Record "Assemble-to-Order Link";    begin        Clear(ATOLink);        ATOLink.SetRange("Assembly Document Type", AssemblyHeader."Document Type");        ATOLink.SetRange("Assembly Document No.", AssemblyHeader."No.");        ATOLink.SetRange(Type, ATOLink.Type::Sale);        ATOLink.SetRange("Document Type", SalesLine."Document Type");        ATOLink.SetRange("Document No.", SalesLine."Document No.");        ATOLink.SetRange("Document Line No.", SalesLine."Line No.");        ATOLink.SetRange("Assembled Quantity", AssemblyHeader."Assembled Quantity");        Assert.AreEqual(NoOfEntries, ATOLink.Count, 'There are no ' + Format(NoOfEntries) + ' entries within the filter ' +          ATOLink.GetFilters);    end;    procedure VerifySaleReservationEntryATO(SalesLine: Record "Sales Line"): Integer    var        ReservationEntry: Record "Reservation Entry";    begin        Clear(ReservationEntry);        ReservationEntry.SetRange(Positive, false);        ReservationEntry.SetRange("Item No.", SalesLine."No.");        ReservationEntry.SetRange(Description, SalesLine.Description);        ReservationEntry.SetRange("Location Code", SalesLine."Location Code");        ReservationEntry.SetRange("Reservation Status", ReservationEntry."Reservation Status"::Reservation);        ReservationEntry.SetRange("Source Type", DATABASE::"Sales Line");        ReservationEntry.SetRange("Source Subtype", SalesLine."Document Type");        ReservationEntry.SetRange("Source Ref. No.", SalesLine."Line No.");        ReservationEntry.SetRange("Source ID", SalesLine."Document No.");        ReservationEntry.SetRange(Quantity, -SalesLine."Qty. to Assemble to Order");        ReservationEntry.SetRange(Binding, ReservationEntry.Binding::"Order-to-Order");        ReservationEntry.SetRange("Planning Flexibility", ReservationEntry."Planning Flexibility"::None);        ReservationEntry.SetRange("Shipment Date", SalesLine."Shipment Date");        ReservationEntry.SetRange("Variant Code", SalesLine."Variant Code");        ReservationEntry.SetRange("Disallow Cancellation", true);        Assert.AreEqual(1, ReservationEntry.Count, 'Couldn''t find the SOL reservation entry with the filters: ' +          ReservationEntry.GetFilters);        exit(ReservationEntry."Entry No.");    end;    procedure VerifyEntityDimensions(TableID: Integer; EntityNo: Code[20]; ParentItemNo: Code[20]; CopyFromHeader: Boolean; DimensionSetID: Integer)    var        DefaultDimension: Record "Default Dimension";        DimensionSetEntry: Record "Dimension Set Entry";    begin        if (TableID <= 0) or (DimensionSetID <= 0) then            exit;        LibraryDimension.FindDefaultDimension(DefaultDimension, TableID, EntityNo);        if CopyFromHeader then            LibraryDimension.FindDefaultDimension(DefaultDimension, 27, ParentItemNo);        LibraryDimension.FindDimensionSetEntry(DimensionSetEntry, DimensionSetID);        repeat            DimensionSetEntry.SetRange("Dimension Code", DefaultDimension."Dimension Code");            DimensionSetEntry.SetRange("Dimension Value Code", DefaultDimension."Dimension Value Code");            Assert.AreEqual(              1, DimensionSetEntry.Count, 'Wrong no. of dimension set entries for dimension ' + Format(DefaultDimension."Dimension Code"));        until DefaultDimension.Next() = 0;    end;    procedure VerifyILEs(var TempAssemblyLine: Record "Assembly Line" temporary; AssemblyHeader: Record "Assembly Header"; AssembledQty: Decimal)    begin        VerifyILEsGeneric(TempAssemblyLine, AssemblyHeader, AssembledQty, false);    end;    procedure VerifyILEsGeneric(var TempAssemblyLine: Record "Assembly Line" temporary; AssemblyHeader: Record "Assembly Header"; AssembledQty: Decimal; IsATO: Boolean)    var        ItemLedgerEntry: Record "Item Ledger Entry";    begin        // General filtering.        ItemLedgerEntry.Reset();        ItemLedgerEntry.SetRange("Posting Date", AssemblyHeader."Posting Date");        ItemLedgerEntry.SetRange("Source No.", AssemblyHeader."Item No.");        ItemLedgerEntry.SetRange("Source Type", ItemLedgerEntry."Source Type"::Item);        ItemLedgerEntry.SetRange("Order Type", ItemLedgerEntry."Order Type"::Assembly);        ItemLedgerEntry.SetRange("Order No.", AssemblyHeader."No.");        ItemLedgerEntry.SetRange("Cost Amount (Expected)", 0);        // Output entry.        ItemLedgerEntry.SetRange("Item No.", AssemblyHeader."Item No.");        ItemLedgerEntry.SetRange("Variant Code", AssemblyHeader."Variant Code");        ItemLedgerEntry.SetRange("Entry Type", ItemLedgerEntry."Entry Type"::"Assembly Output");        ItemLedgerEntry.SetRange("Location Code", AssemblyHeader."Location Code");        ItemLedgerEntry.SetRange(Quantity, AssembledQty);        ItemLedgerEntry.SetRange("Invoiced Quantity", AssembledQty);        ItemLedgerEntry.SetRange("Unit of Measure Code", AssemblyHeader."Unit of Measure Code");        ItemLedgerEntry.SetRange("Document Line No.", 0);        ItemLedgerEntry.SetRange("Order Line No.", 0);        ItemLedgerEntry.SetRange("Dimension Set ID", AssemblyHeader."Dimension Set ID");        ItemLedgerEntry.SetRange("Assemble to Order", false);        if IsATO then begin            ItemLedgerEntry.SetRange("Remaining Quantity", 0);            ItemLedgerEntry.SetRange(Open, false);        end else begin            ItemLedgerEntry.SetRange("Remaining Quantity", AssembledQty);            ItemLedgerEntry.SetRange(Open, true);        end;        Assert.AreEqual(1, ItemLedgerEntry.Count, 'Wrong no. of output entries for item ' + AssemblyHeader."Item No.");        ItemLedgerEntry.FindFirst();        VerifyApplicationEntry(ItemLedgerEntry);        // Consumption entries.        // Find posted assembly lines.        TempAssemblyLine.SetRange(Type, TempAssemblyLine.Type::Item);        if TempAssemblyLine.FindSet() then            repeat                Clear(ItemLedgerEntry);                ItemLedgerEntry.SetRange("Item No.", TempAssemblyLine."No.");                ItemLedgerEntry.SetRange("Variant Code", TempAssemblyLine."Variant Code");                ItemLedgerEntry.SetRange("Entry Type", ItemLedgerEntry."Entry Type"::"Assembly Consumption");                ItemLedgerEntry.SetRange("Location Code", TempAssemblyLine."Location Code");                ItemLedgerEntry.SetRange(Quantity, -TempAssemblyLine."Quantity to Consume (Base)");                ItemLedgerEntry.SetRange("Remaining Quantity", 0);                ItemLedgerEntry.SetRange("Invoiced Quantity", -TempAssemblyLine."Quantity to Consume (Base)");                ItemLedgerEntry.SetRange("Unit of Measure Code", TempAssemblyLine."Unit of Measure Code");                ItemLedgerEntry.SetRange(Open, false);                ItemLedgerEntry.SetRange("Document Line No.", TempAssemblyLine."Line No.");                ItemLedgerEntry.SetRange("Order Line No.", TempAssemblyLine."Line No.");                ItemLedgerEntry.SetRange("Dimension Set ID", TempAssemblyLine."Dimension Set ID");                ItemLedgerEntry.SetRange("Assemble to Order", false);                Assert.AreEqual(1, ItemLedgerEntry.Count, 'Wrong no. of consumpt. ILEs for item ' + TempAssemblyLine."No.");                ItemLedgerEntry.FindFirst();                VerifyApplicationEntry(ItemLedgerEntry);            until TempAssemblyLine.Next() = 0;    end;    procedure VerifyILEsForAsmOnATO(var TempAssemblyLine: Record "Assembly Line" temporary; AssemblyHeader: Record "Assembly Header"; AssembledQty: Decimal)    begin        VerifyILEsGeneric(TempAssemblyLine, AssemblyHeader, AssembledQty, true);    end;    procedure VerifyILEsUndo(var TempPostedAssemblyHeader: Record "Posted Assembly Header" temporary; var TempPostedAssemblyLine: Record "Posted Assembly Line" temporary; UndoEntries: Boolean)    var        ItemLedgerEntry: Record "Item Ledger Entry";    begin        // General filtering.        ItemLedgerEntry.Reset();        ItemLedgerEntry.SetRange("Posting Date", TempPostedAssemblyHeader."Posting Date");        ItemLedgerEntry.SetRange("Source No.", TempPostedAssemblyHeader."Item No.");        ItemLedgerEntry.SetRange("Source Type", ItemLedgerEntry."Source Type"::Item);        ItemLedgerEntry.SetRange("Order Type", ItemLedgerEntry."Order Type"::Assembly);        ItemLedgerEntry.SetRange("Order No.", TempPostedAssemblyHeader."Order No.");        ItemLedgerEntry.SetRange("Cost Amount (Expected)", 0);        // Output entry.        ItemLedgerEntry.SetRange("Item No.", TempPostedAssemblyHeader."Item No.");        ItemLedgerEntry.SetRange("Variant Code", TempPostedAssemblyHeader."Variant Code");        ItemLedgerEntry.SetRange("Entry Type", ItemLedgerEntry."Entry Type"::"Assembly Output");        ItemLedgerEntry.SetRange("Location Code", TempPostedAssemblyHeader."Location Code");        if UndoEntries then begin            ItemLedgerEntry.SetRange(Quantity, -TempPostedAssemblyHeader."Quantity (Base)");            ItemLedgerEntry.SetRange("Invoiced Quantity", -TempPostedAssemblyHeader."Quantity (Base)");        end else begin            ItemLedgerEntry.SetRange(Quantity, TempPostedAssemblyHeader."Quantity (Base)");            ItemLedgerEntry.SetRange("Invoiced Quantity", TempPostedAssemblyHeader."Quantity (Base)");        end;        ItemLedgerEntry.SetRange("Assemble to Order", false);        ItemLedgerEntry.SetRange("Unit of Measure Code", TempPostedAssemblyHeader."Unit of Measure Code");        ItemLedgerEntry.SetRange("Document Line No.", 0);        ItemLedgerEntry.SetRange("Order Line No.", 0);        ItemLedgerEntry.SetRange("Dimension Set ID", TempPostedAssemblyHeader."Dimension Set ID");        ItemLedgerEntry.SetRange("Remaining Quantity", 0);        ItemLedgerEntry.SetRange(Open, false);        ItemLedgerEntry.SetRange(Correction, UndoEntries);        Assert.AreEqual(1, ItemLedgerEntry.Count, 'Wrong no. of output entries for item ' + TempPostedAssemblyHeader."Item No.");        // Verify application entries        ItemLedgerEntry.FindFirst();        VerifyApplicationEntryUndo(ItemLedgerEntry);        // Consumption entries.        // Find posted assembly lines.        TempPostedAssemblyLine.SetRange(Type, TempPostedAssemblyLine.Type::Item);        if TempPostedAssemblyLine.FindSet() then            repeat                Clear(ItemLedgerEntry);                ItemLedgerEntry.SetRange("Order Type", ItemLedgerEntry."Order Type"::Assembly);                ItemLedgerEntry.SetRange("Order No.", TempPostedAssemblyHeader."Order No.");                ItemLedgerEntry.SetRange("Item No.", TempPostedAssemblyLine."No.");                ItemLedgerEntry.SetRange("Variant Code", TempPostedAssemblyLine."Variant Code");                ItemLedgerEntry.SetRange("Entry Type", ItemLedgerEntry."Entry Type"::"Assembly Consumption");                ItemLedgerEntry.SetRange("Location Code", TempPostedAssemblyLine."Location Code");                if UndoEntries then begin                    ItemLedgerEntry.SetRange(Quantity, TempPostedAssemblyLine."Quantity (Base)");                    ItemLedgerEntry.SetRange("Remaining Quantity", TempPostedAssemblyLine."Quantity (Base)");                    ItemLedgerEntry.SetRange("Invoiced Quantity", TempPostedAssemblyLine."Quantity (Base)");                end else begin                    ItemLedgerEntry.SetRange(Quantity, -TempPostedAssemblyLine."Quantity (Base)");                    ItemLedgerEntry.SetRange("Remaining Quantity", 0);                    ItemLedgerEntry.SetRange("Invoiced Quantity", -TempPostedAssemblyLine."Quantity (Base)");                end;                ItemLedgerEntry.SetRange("Assemble to Order", false);                ItemLedgerEntry.SetRange("Unit of Measure Code", TempPostedAssemblyLine."Unit of Measure Code");                ItemLedgerEntry.SetRange(Open, UndoEntries);                ItemLedgerEntry.SetRange(Correction, UndoEntries);                ItemLedgerEntry.SetRange("Document Line No.", TempPostedAssemblyLine."Line No.");                ItemLedgerEntry.SetRange("Order Line No.", TempPostedAssemblyLine."Line No.");                ItemLedgerEntry.SetRange("Dimension Set ID", TempPostedAssemblyLine."Dimension Set ID");                Assert.AreEqual(1, ItemLedgerEntry.Count, 'Wrong no. of consumpt. ILEs for item ' + TempPostedAssemblyLine."No.");                ItemLedgerEntry.FindFirst();                VerifyApplicationEntryUndo(ItemLedgerEntry);            until TempPostedAssemblyLine.Next() = 0;    end;    procedure VerifyILEATOAndSale(AssemblyHeader: Record "Assembly Header"; SalesLine: Record "Sales Line"; AssembledQty: Decimal; Invoiced: Boolean; NoOfLines: Integer)    var        ItemLedgerEntry: Record "Item Ledger Entry";    begin        // General filtering.        ItemLedgerEntry.Reset();        ItemLedgerEntry.SetRange("Posting Date", AssemblyHeader."Posting Date");        ItemLedgerEntry.SetRange("Source No.", AssemblyHeader."Item No.");        ItemLedgerEntry.SetRange("Source Type", ItemLedgerEntry."Source Type"::Item);        ItemLedgerEntry.SetRange("Order Type", ItemLedgerEntry."Order Type"::Assembly);        ItemLedgerEntry.SetRange("Order No.", AssemblyHeader."No.");        ItemLedgerEntry.SetRange("Cost Amount (Expected)", 0);        // Output entry.        ItemLedgerEntry.SetRange("Item No.", AssemblyHeader."Item No.");        ItemLedgerEntry.SetRange("Variant Code", AssemblyHeader."Variant Code");        ItemLedgerEntry.SetRange("Entry Type", ItemLedgerEntry."Entry Type"::"Assembly Output");        ItemLedgerEntry.SetRange("Location Code", AssemblyHeader."Location Code");        ItemLedgerEntry.SetRange(Quantity, AssembledQty);        ItemLedgerEntry.SetRange("Invoiced Quantity", AssembledQty);        ItemLedgerEntry.SetRange("Unit of Measure Code", AssemblyHeader."Unit of Measure Code");        ItemLedgerEntry.SetRange("Document Line No.", 0);        ItemLedgerEntry.SetRange("Order Line No.", 0);        ItemLedgerEntry.SetRange("Dimension Set ID", AssemblyHeader."Dimension Set ID");        ItemLedgerEntry.SetRange("Assemble to Order", false);        ItemLedgerEntry.SetRange("Remaining Quantity", 0);        ItemLedgerEntry.SetRange(Open, false);        Assert.AreEqual(NoOfLines, ItemLedgerEntry.Count, 'Wrong no. of output entries for item ' + AssemblyHeader."Item No.");        if ItemLedgerEntry.FindSet() then            repeat                VerifyILESale(SalesLine, AssembledQty, ItemLedgerEntry."Entry No.", true, Invoiced);            until ItemLedgerEntry.Next() = 0;    end;    procedure VerifyILESale(SalesLine: Record "Sales Line"; AssembledQty: Decimal; EntryNo: Integer; IsAto: Boolean; Invoiced: Boolean)    var        ItemLedgerEntry: Record "Item Ledger Entry";    begin        // General filtering.        ItemLedgerEntry.Reset();        ItemLedgerEntry.SetRange("Source No.", SalesLine."Sell-to Customer No.");        ItemLedgerEntry.SetRange("Source Type", ItemLedgerEntry."Source Type"::Customer);        ItemLedgerEntry.SetRange("Order Type", ItemLedgerEntry."Order Type"::" ");        ItemLedgerEntry.SetRange("Cost Amount (Expected)", 0);        // Output entry.        ItemLedgerEntry.SetRange("Item No.", SalesLine."No.");        ItemLedgerEntry.SetRange("Variant Code", SalesLine."Variant Code");        ItemLedgerEntry.SetRange("Entry Type", ItemLedgerEntry."Entry Type"::Sale);        ItemLedgerEntry.SetRange("Location Code", SalesLine."Location Code");        ItemLedgerEntry.SetRange(Quantity, -AssembledQty);        if Invoiced then            ItemLedgerEntry.SetRange("Invoiced Quantity", -AssembledQty)        else            ItemLedgerEntry.SetRange("Invoiced Quantity", 0);        ItemLedgerEntry.SetRange("Unit of Measure Code", SalesLine."Unit of Measure Code");        ItemLedgerEntry.SetRange("Document Line No.", SalesLine."Line No.");        ItemLedgerEntry.SetRange("Order Line No.", 0);        ItemLedgerEntry.SetRange("Dimension Set ID", SalesLine."Dimension Set ID");        ItemLedgerEntry.SetRange("Assemble to Order", IsAto);        ItemLedgerEntry.SetRange(Open, not IsAto);        if IsAto then            ItemLedgerEntry.SetRange("Remaining Quantity", 0)        else            ItemLedgerEntry.SetRange("Remaining Quantity", -AssembledQty);        ItemLedgerEntry.SetRange("Applies-to Entry", EntryNo);        Assert.AreEqual(1, ItemLedgerEntry.Count, 'Wrong no. of sale entries for item ' + SalesLine."No.");    end;    procedure VerifySKUCost(var TempAssemblyLine: Record "Assembly Line" temporary; AssemblyHeader: Record "Assembly Header")    var        Item: Record Item;        UnitCost: Decimal;        Overhead: Decimal;        IndirectCost: Decimal;    begin        // Check header item SKU cost.        Item.Get(AssemblyHeader."Item No.");        GetCostInformation(UnitCost, Overhead, IndirectCost, "BOM Component Type"::Item, AssemblyHeader."Item No.",          AssemblyHeader."Variant Code", AssemblyHeader."Location Code");        if Item."Costing Method" = Item."Costing Method"::Standard then            AssemblyHeader.TestField("Unit Cost", UnitCost);        // Check item components SKU cost.        TempAssemblyLine.SetRange(Type, TempAssemblyLine.Type::Item);        if TempAssemblyLine.FindSet() then            repeat                GetCostInformation(UnitCost, Overhead, IndirectCost, "BOM Component Type"::Item, TempAssemblyLine."No.",                  TempAssemblyLine."Variant Code", TempAssemblyLine."Location Code");                TempAssemblyLine.TestField("Unit Cost", UnitCost);            until TempAssemblyLine.Next() = 0    end;    procedure VerifyValueEntries(var TempAssemblyLine: Record "Assembly Line" temporary; AssemblyHeader: Record "Assembly Header"; AssembledQty: Decimal)    begin        VerifyValueEntriesAsm(TempAssemblyLine, AssemblyHeader, AssembledQty);    end;    procedure VerifyValueEntriesAsm(var TempAssemblyLine: Record "Assembly Line" temporary; AssemblyHeader: Record "Assembly Header"; AssembledQty: Decimal)    var        ValueEntry: Record "Value Entry";    begin        ValueEntry.Reset();        // General filtering.        ValueEntry.SetRange("Posting Date", AssemblyHeader."Posting Date");        ValueEntry.SetRange("Source No.", AssemblyHeader."Item No.");        ValueEntry.SetRange("Source Type", ValueEntry."Source Type"::Item);        ValueEntry.SetRange("Order Type", ValueEntry."Order Type"::Assembly);        ValueEntry.SetRange("Order No.", AssemblyHeader."No.");        ValueEntry.SetRange("Entry Type", ValueEntry."Entry Type"::"Direct Cost");        // Output entry.        ValueEntry.SetRange("Item No.", AssemblyHeader."Item No.");        ValueEntry.SetRange("Variant Code", AssemblyHeader."Variant Code");        ValueEntry.SetRange("Item Ledger Entry Type", ValueEntry."Item Ledger Entry Type"::"Assembly Output");        ValueEntry.SetRange("Location Code", AssemblyHeader."Location Code");        ValueEntry.SetRange("Valued Quantity", AssembledQty);        ValueEntry.SetRange("Item Ledger Entry Quantity", AssembledQty);        ValueEntry.SetRange("Invoiced Quantity", AssembledQty);        ValueEntry.SetRange("Document Line No.", 0);        ValueEntry.SetRange("Order Line No.", 0);        ValueEntry.SetRange("Dimension Set ID", AssemblyHeader."Dimension Set ID");        ValueEntry.SetRange(Adjustment, false);        Assert.AreEqual(1, ValueEntry.Count, 'Wrong no. of output value entries for item' + AssemblyHeader."Item No.");        ValueEntry.FindFirst();        Assert.AreNearlyEqual(Round(AssemblyHeader."Cost Amount" * AssembledQty / AssemblyHeader.Quantity,            LibraryERM.GetAmountRoundingPrecision()),          ValueEntry."Cost Amount (Actual)", LibraryERM.GetAmountRoundingPrecision(), 'Wrong value entry cost amount for header.');        // Consumption value entries for items.        TempAssemblyLine.SetRange(Type, TempAssemblyLine.Type::Item);        if TempAssemblyLine.FindSet() then            repeat                ValueEntry.SetRange("Item No.", TempAssemblyLine."No.");                ValueEntry.SetRange("Variant Code", TempAssemblyLine."Variant Code");                ValueEntry.SetRange("Item Ledger Entry Type", ValueEntry."Item Ledger Entry Type"::"Assembly Consumption");                ValueEntry.SetRange("Location Code", TempAssemblyLine."Location Code");                ValueEntry.SetRange("Valued Quantity", -TempAssemblyLine."Quantity to Consume (Base)");                ValueEntry.SetRange("Item Ledger Entry Quantity", -TempAssemblyLine."Quantity to Consume (Base)");                ValueEntry.SetRange("Invoiced Quantity", -TempAssemblyLine."Quantity to Consume (Base)");                ValueEntry.SetRange("Document Line No.", TempAssemblyLine."Line No.");                ValueEntry.SetRange("Order Line No.", TempAssemblyLine."Line No.");                ValueEntry.SetRange("Dimension Set ID", TempAssemblyLine."Dimension Set ID");                Assert.AreEqual(1, ValueEntry.Count, 'Wrong no. of consumpt. value entries for item' + TempAssemblyLine."No.");                ValueEntry.FindFirst();                Assert.AreNearlyEqual(                  TempAssemblyLine."Cost Amount" * Round(TempAssemblyLine."Quantity to Consume" / TempAssemblyLine.Quantity),                  -ValueEntry."Cost Amount (Actual)", LibraryERM.GetAmountRoundingPrecision(),                  'Wrong value entry cost amount for item ' + TempAssemblyLine."No.");            until TempAssemblyLine.Next() = 0;        // Consumption value entries for resources.        TempAssemblyLine.SetRange(Type, TempAssemblyLine.Type::Resource);        if TempAssemblyLine.FindSet() then            repeat                ValueEntry.SetRange("Item No.", '');                ValueEntry.SetRange("Variant Code", TempAssemblyLine."Variant Code");                ValueEntry.SetRange("Item Ledger Entry Type", ValueEntry."Item Ledger Entry Type"::" ");                ValueEntry.SetRange("Location Code", TempAssemblyLine."Location Code");                ValueEntry.SetRange(Description, TempAssemblyLine.Description);                ValueEntry.SetRange("Valued Quantity", TempAssemblyLine."Quantity to Consume");                ValueEntry.SetRange("Item Ledger Entry Quantity", 0);                ValueEntry.SetRange("Invoiced Quantity", TempAssemblyLine."Quantity to Consume");                ValueEntry.SetRange("Document Line No.", TempAssemblyLine."Line No.");                ValueEntry.SetRange("Order Line No.", TempAssemblyLine."Line No.");                ValueEntry.SetRange("Dimension Set ID", TempAssemblyLine."Dimension Set ID");                ValueEntry.SetRange(Type, ValueEntry.Type::Resource);                ValueEntry.SetRange("No.", TempAssemblyLine."No.");                Assert.AreEqual(1, ValueEntry.Count, 'Wrong no. of res. consumpt. value entries for res. ' + TempAssemblyLine."No.");                ValueEntry.FindFirst();                Assert.AreNearlyEqual(TempAssemblyLine."Cost Amount" * TempAssemblyLine."Quantity to Consume" /                  TempAssemblyLine.Quantity, ValueEntry."Cost Amount (Actual)",                  LibraryERM.GetAmountRoundingPrecision(), 'Wrong value entry cost amount for res. ' + TempAssemblyLine."No.");            until TempAssemblyLine.Next() = 0;    end;    procedure VerifyValueEntriesATO(var TempAssemblyLine: Record "Assembly Line" temporary; SalesHeader: Record "Sales Header"; AssemblyHeader: Record "Assembly Header"; AssembledQty: Decimal)    begin        VerifyValueEntriesAsm(TempAssemblyLine, AssemblyHeader, AssembledQty);        VerifyValueEntriesSale(SalesHeader, AssemblyHeader, AssembledQty);    end;    procedure VerifyValueEntriesSale(SalesHeader: Record "Sales Header"; AssemblyHeader: Record "Assembly Header"; AssembledQty: Decimal)    var        ValueEntry: Record "Value Entry";    begin        ValueEntry.Reset();        ValueEntry.SetRange("Posting Date", AssemblyHeader."Posting Date");        ValueEntry.SetRange("Source No.", SalesHeader."Sell-to Customer No.");        ValueEntry.SetRange("Source Type", ValueEntry."Source Type"::Customer);        ValueEntry.SetRange("Order Type", ValueEntry."Order Type"::" ");        ValueEntry.SetRange("Order No.", '');        ValueEntry.SetRange("Entry Type", ValueEntry."Entry Type"::"Direct Cost");        ValueEntry.SetRange("Item No.", AssemblyHeader."Item No.");        ValueEntry.SetRange("Variant Code", AssemblyHeader."Variant Code");        ValueEntry.SetRange("Item Ledger Entry Type", ValueEntry."Item Ledger Entry Type"::Sale);        ValueEntry.SetRange("Location Code", AssemblyHeader."Location Code");        ValueEntry.SetRange("Valued Quantity", -AssembledQty);        ValueEntry.SetRange("Item Ledger Entry Quantity", -AssembledQty);        ValueEntry.SetRange("Invoiced Quantity", -AssembledQty);        ValueEntry.SetRange(Adjustment, false);        Assert.AreEqual(1, ValueEntry.Count, 'Wrong no. of sales value entries for item' + AssemblyHeader."Item No.");        ValueEntry.FindFirst();        Assert.AreNearlyEqual(Round(AssemblyHeader."Cost Amount" * AssembledQty / AssemblyHeader.Quantity,            LibraryERM.GetAmountRoundingPrecision()),          ValueEntry."Cost Amount (Actual)", LibraryERM.GetAmountRoundingPrecision(), 'Wrong value entry cost amount for header.');    end;    procedure VerifyValueEntriesUndo(var TempAssemblyLine: Record "Assembly Line" temporary; AssemblyHeader: Record "Assembly Header"; AssembledQty: Decimal)    var        ValueEntry: Record "Value Entry";    begin        ValueEntry.Reset();        // General filtering.        ValueEntry.SetRange("Posting Date", AssemblyHeader."Posting Date");        ValueEntry.SetRange("Source No.", AssemblyHeader."Item No.");        ValueEntry.SetRange("Source Type", ValueEntry."Source Type"::Item);        ValueEntry.SetRange("Order Type", ValueEntry."Order Type"::Assembly);        ValueEntry.SetRange("Order No.", AssemblyHeader."No.");        ValueEntry.SetRange("Entry Type", ValueEntry."Entry Type"::"Direct Cost");        // Output entry.        ValueEntry.SetRange("Item No.", AssemblyHeader."Item No.");        ValueEntry.SetRange("Variant Code", AssemblyHeader."Variant Code");        ValueEntry.SetRange("Item Ledger Entry Type", ValueEntry."Item Ledger Entry Type"::"Assembly Output");        ValueEntry.SetRange("Location Code", AssemblyHeader."Location Code");        ValueEntry.SetRange("Valued Quantity", AssembledQty);        ValueEntry.SetRange("Item Ledger Entry Quantity", AssembledQty);        ValueEntry.SetRange("Invoiced Quantity", AssembledQty);        ValueEntry.SetRange("Document Line No.", 0);        ValueEntry.SetRange("Order Line No.", 0);        ValueEntry.SetRange("Dimension Set ID", AssemblyHeader."Dimension Set ID");        ValueEntry.SetRange(Adjustment, false);        Assert.AreEqual(1, ValueEntry.Count, 'Wrong no. of output value entries for item' + AssemblyHeader."Item No.");        ValueEntry.FindFirst();        Assert.AreNearlyEqual(Round(AssemblyHeader."Cost Amount" * AssembledQty / AssemblyHeader.Quantity,            LibraryERM.GetAmountRoundingPrecision()),          ValueEntry."Cost Amount (Actual)", LibraryERM.GetAmountRoundingPrecision(), 'Wrong value entry cost amount for header.');        // Consumption value entries for items.        TempAssemblyLine.SetRange(Type, TempAssemblyLine.Type::Item);        if TempAssemblyLine.FindSet() then            repeat                ValueEntry.SetRange("Item No.", TempAssemblyLine."No.");                ValueEntry.SetRange("Variant Code", TempAssemblyLine."Variant Code");                ValueEntry.SetRange("Item Ledger Entry Type", ValueEntry."Item Ledger Entry Type"::"Assembly Consumption");                ValueEntry.SetRange("Location Code", TempAssemblyLine."Location Code");                ValueEntry.SetRange("Valued Quantity", -TempAssemblyLine."Quantity to Consume (Base)");                ValueEntry.SetRange("Item Ledger Entry Quantity", -TempAssemblyLine."Quantity to Consume (Base)");                ValueEntry.SetRange("Invoiced Quantity", -TempAssemblyLine."Quantity to Consume (Base)");                ValueEntry.SetRange("Document Line No.", TempAssemblyLine."Line No.");                ValueEntry.SetRange("Order Line No.", TempAssemblyLine."Line No.");                ValueEntry.SetRange("Dimension Set ID", TempAssemblyLine."Dimension Set ID");                Assert.AreEqual(1, ValueEntry.Count, 'Wrong no. of consumpt. value entries for item' + TempAssemblyLine."No.");                ValueEntry.FindFirst();                Assert.AreNearlyEqual(Round(TempAssemblyLine."Cost Amount" * TempAssemblyLine."Quantity to Consume" /                    TempAssemblyLine.Quantity, LibraryERM.GetAmountRoundingPrecision()),                  -ValueEntry."Cost Amount (Actual)", LibraryERM.GetAmountRoundingPrecision(),                  'Wrong value entry cost amount for item ' + TempAssemblyLine."No.");            until TempAssemblyLine.Next() = 0;        // Consumption value entries for resources.        TempAssemblyLine.SetRange(Type, TempAssemblyLine.Type::Resource);        if TempAssemblyLine.FindSet() then            repeat                ValueEntry.SetRange("Item No.", '');                ValueEntry.SetRange("Variant Code", TempAssemblyLine."Variant Code");                ValueEntry.SetRange("Item Ledger Entry Type", ValueEntry."Item Ledger Entry Type"::" ");                ValueEntry.SetRange("Location Code", TempAssemblyLine."Location Code");                ValueEntry.SetRange(Description, TempAssemblyLine.Description);                ValueEntry.SetRange("Valued Quantity", TempAssemblyLine."Quantity to Consume");                ValueEntry.SetRange("Item Ledger Entry Quantity", 0);                ValueEntry.SetRange("Invoiced Quantity", TempAssemblyLine."Quantity to Consume");                ValueEntry.SetRange("Document Line No.", TempAssemblyLine."Line No.");                ValueEntry.SetRange("Order Line No.", TempAssemblyLine."Line No.");                ValueEntry.SetRange("Dimension Set ID", TempAssemblyLine."Dimension Set ID");                ValueEntry.SetRange(Type, ValueEntry.Type::Resource);                ValueEntry.SetRange("No.", TempAssemblyLine."No.");                Assert.AreEqual(1, ValueEntry.Count, 'Wrong no. of res. consumpt. value entries for res. ' + TempAssemblyLine."No.");                ValueEntry.FindFirst();                Assert.AreNearlyEqual(TempAssemblyLine."Cost Amount" * TempAssemblyLine."Quantity to Consume" /                  TempAssemblyLine.Quantity, ValueEntry."Cost Amount (Actual)",                  LibraryERM.GetAmountRoundingPrecision(), 'Wrong value entry cost amount for res. ' + TempAssemblyLine."No.");            until TempAssemblyLine.Next() = 0;    end;    procedure VerifyResEntries(var TempAssemblyLine: Record "Assembly Line" temporary; AssemblyHeader: Record "Assembly Header")    begin        VerifyResEntriesGeneric(TempAssemblyLine, AssemblyHeader, false);    end;    procedure VerifyResEntriesATO(var TempAssemblyLine: Record "Assembly Line" temporary; AssemblyHeader: Record "Assembly Header")    begin        VerifyResEntriesGeneric(TempAssemblyLine, AssemblyHeader, true);    end;    procedure VerifyResEntriesGeneric(var TempAssemblyLine: Record "Assembly Line" temporary; AssemblyHeader: Record "Assembly Header"; IsATO: Boolean)    var        ResLedgerEntry: Record "Res. Ledger Entry";        SourceCodeSetup: Record "Source Code Setup";    begin        SourceCodeSetup.Get();        ResLedgerEntry.Reset();        // General filtering.        ResLedgerEntry.SetRange("Posting Date", AssemblyHeader."Posting Date");        ResLedgerEntry.SetRange("Order Type", ResLedgerEntry."Order Type"::Assembly);        ResLedgerEntry.SetRange("Order No.", AssemblyHeader."No.");        ResLedgerEntry.SetRange("Entry Type", ResLedgerEntry."Entry Type"::Usage);        if IsATO then            ResLedgerEntry.SetRange("Source Code", SourceCodeSetup.Sales)        else            ResLedgerEntry.SetRange("Source Code", SourceCodeSetup.Assembly);        // Usage entries.        TempAssemblyLine.SetRange(Type, TempAssemblyLine.Type::Resource);        if TempAssemblyLine.FindSet() then            repeat                ResLedgerEntry.SetRange("Resource No.", TempAssemblyLine."No.");                ResLedgerEntry.SetRange(Quantity, TempAssemblyLine."Quantity to Consume");                ResLedgerEntry.SetRange("Unit of Measure Code", TempAssemblyLine."Unit of Measure Code");                if not IsATO then begin // if ATO then dimensions can come from SOL also - skip checking them                    ResLedgerEntry.SetRange("Global Dimension 1 Code", TempAssemblyLine."Shortcut Dimension 1 Code");                    ResLedgerEntry.SetRange("Global Dimension 2 Code", TempAssemblyLine."Shortcut Dimension 2 Code");                    ResLedgerEntry.SetRange("Dimension Set ID", TempAssemblyLine."Dimension Set ID");                end;                ResLedgerEntry.SetRange("Order Line No.", TempAssemblyLine."Line No.");                Assert.AreEqual(1, ResLedgerEntry.Count, 'Wrong no. of res ledger entries for res. ' + TempAssemblyLine."No.");                ResLedgerEntry.FindFirst();                Assert.AreNearlyEqual(Round(TempAssemblyLine."Cost Amount" * TempAssemblyLine."Quantity to Consume" /                    TempAssemblyLine.Quantity, LibraryERM.GetAmountRoundingPrecision()), ResLedgerEntry."Total Cost",                  LibraryERM.GetAmountRoundingPrecision(), 'Wrong Res. Ledger Cost amount for res. ' + TempAssemblyLine."No.")            until TempAssemblyLine.Next() = 0;    end;    procedure VerifyCapEntries(var TempAssemblyLine: Record "Assembly Line" temporary; AssemblyHeader: Record "Assembly Header")    begin        VerifyCapEntriesGeneric(TempAssemblyLine, AssemblyHeader, false);    end;    procedure VerifyCapEntriesATO(var TempAssemblyLine: Record "Assembly Line" temporary; AssemblyHeader: Record "Assembly Header")    begin        VerifyCapEntriesGeneric(TempAssemblyLine, AssemblyHeader, true);    end;    procedure VerifyCapEntriesGeneric(var TempAssemblyLine: Record "Assembly Line" temporary; AssemblyHeader: Record "Assembly Header"; IsATO: Boolean)    var        CapacityLedgerEntry: Record "Capacity Ledger Entry";    begin        CapacityLedgerEntry.Reset();        // General filtering.        CapacityLedgerEntry.SetRange("Posting Date", AssemblyHeader."Posting Date");        CapacityLedgerEntry.SetRange(Type, CapacityLedgerEntry.Type::Resource);        CapacityLedgerEntry.SetRange("Item No.", AssemblyHeader."Item No.");        CapacityLedgerEntry.SetRange("Variant Code", AssemblyHeader."Variant Code");        CapacityLedgerEntry.SetRange("Unit of Measure Code", AssemblyHeader."Unit of Measure Code");        CapacityLedgerEntry.SetRange("Order Type", CapacityLedgerEntry."Order Type"::Assembly);        CapacityLedgerEntry.SetRange("Order No.", AssemblyHeader."No.");        // Usage entries.        TempAssemblyLine.SetRange(Type, TempAssemblyLine.Type::Resource);        if TempAssemblyLine.FindSet() then            repeat                CapacityLedgerEntry.SetRange("No.", TempAssemblyLine."No.");                CapacityLedgerEntry.SetRange(Description, TempAssemblyLine.Description);                CapacityLedgerEntry.SetRange(Quantity, TempAssemblyLine."Quantity to Consume");                CapacityLedgerEntry.SetRange("Invoiced Quantity", TempAssemblyLine."Quantity to Consume");                CapacityLedgerEntry.SetRange("Cap. Unit of Measure Code", TempAssemblyLine."Unit of Measure Code");                if not IsATO then begin // if ATO then dimensions can come from SOL also - skip checking them                    CapacityLedgerEntry.SetRange("Global Dimension 1 Code", TempAssemblyLine."Shortcut Dimension 1 Code");                    CapacityLedgerEntry.SetRange("Global Dimension 2 Code", TempAssemblyLine."Shortcut Dimension 2 Code");                    CapacityLedgerEntry.SetRange("Dimension Set ID", TempAssemblyLine."Dimension Set ID");                end;                Assert.AreEqual(1, CapacityLedgerEntry.Count, 'Wrong no. of capacity ledger entries for res. ' + TempAssemblyLine."No.");                CapacityLedgerEntry.FindFirst();                CapacityLedgerEntry.CalcFields("Direct Cost");                Assert.AreNearlyEqual(TempAssemblyLine."Cost Amount" * TempAssemblyLine."Quantity to Consume" /                  TempAssemblyLine.Quantity, CapacityLedgerEntry."Direct Cost",                  LibraryERM.GetAmountRoundingPrecision(), 'Wrong Cap. Ledger Cost amount for res. ' + TempAssemblyLine."No.")            until TempAssemblyLine.Next() = 0;    end;    procedure VerifyCapEntriesUndo(var TempPostedAssemblyHeader: Record "Posted Assembly Header" temporary; var TempPostedAssemblyLine: Record "Posted Assembly Line" temporary; IsUndo: Boolean)    var        CapacityLedgerEntry: Record "Capacity Ledger Entry";    begin        CapacityLedgerEntry.Reset();        // General filtering.        CapacityLedgerEntry.SetRange("Posting Date", TempPostedAssemblyHeader."Posting Date");        CapacityLedgerEntry.SetRange(Type, CapacityLedgerEntry.Type::Resource);        CapacityLedgerEntry.SetRange("Item No.", TempPostedAssemblyHeader."Item No.");        CapacityLedgerEntry.SetRange("Variant Code", TempPostedAssemblyHeader."Variant Code");        CapacityLedgerEntry.SetRange("Unit of Measure Code", TempPostedAssemblyHeader."Unit of Measure Code");        CapacityLedgerEntry.SetRange("Order Type", CapacityLedgerEntry."Order Type"::Assembly);        CapacityLedgerEntry.SetRange("Order No.", TempPostedAssemblyHeader."Order No.");        // Usage entries.        TempPostedAssemblyLine.SetRange(Type, TempPostedAssemblyLine.Type::Resource);        if TempPostedAssemblyLine.FindSet() then            repeat                CapacityLedgerEntry.SetRange("No.", TempPostedAssemblyLine."No.");                CapacityLedgerEntry.SetRange(Description, TempPostedAssemblyLine.Description);                CapacityLedgerEntry.SetRange("Cap. Unit of Measure Code", TempPostedAssemblyLine."Unit of Measure Code");                CapacityLedgerEntry.SetRange("Global Dimension 1 Code", TempPostedAssemblyLine."Shortcut Dimension 1 Code");                CapacityLedgerEntry.SetRange("Global Dimension 2 Code", TempPostedAssemblyLine."Shortcut Dimension 2 Code");                CapacityLedgerEntry.SetRange("Dimension Set ID", TempPostedAssemblyLine."Dimension Set ID");                if IsUndo then begin                    CapacityLedgerEntry.SetRange(Quantity, -TempPostedAssemblyLine."Quantity (Base)");                    CapacityLedgerEntry.SetRange("Invoiced Quantity", -TempPostedAssemblyLine."Quantity (Base)");                end else begin                    CapacityLedgerEntry.SetRange(Quantity, TempPostedAssemblyLine."Quantity (Base)");                    CapacityLedgerEntry.SetRange("Invoiced Quantity", TempPostedAssemblyLine."Quantity (Base)");                end;                Assert.AreEqual(1, CapacityLedgerEntry.Count, 'Wrong no. of capacity ledger entries for res. ' + TempPostedAssemblyLine."No.");            until TempPostedAssemblyLine.Next() = 0;    end;    procedure VerifyComments(AssemblyHeader: Record "Assembly Header")    var        AssemblyLine: Record "Assembly Line";    begin        VerifyLineComment(AssemblyHeader, 0);        AssemblyLine.SetRange("Document Type", AssemblyHeader."Document Type");        AssemblyLine.SetRange("Document No.", AssemblyHeader."No.");        if AssemblyLine.FindSet() then            repeat                VerifyLineComment(AssemblyHeader, AssemblyLine."Line No.");            until AssemblyLine.Next() = 0;    end;    procedure VerifyLineComment(AssemblyHeader: Record "Assembly Header"; AssemblyLineNo: Integer)    var        AssemblyCommentLine: Record "Assembly Comment Line";    begin        AssemblyCommentLine.Reset();        AssemblyCommentLine.SetRange("Document Type", AssemblyCommentLine."Document Type"::"Assembly Order");        AssemblyCommentLine.SetRange("Document No.", AssemblyHeader."No.");        AssemblyCommentLine.SetRange("Document Line No.", AssemblyLineNo);        AssemblyCommentLine.SetRange(Comment, 'Order:' + AssemblyHeader."No." + ', Line:' + Format(AssemblyLineNo));        AssemblyCommentLine.FindFirst();        Assert.AreEqual(1, AssemblyCommentLine.Count, 'Wrong no. of comment lines.');    end;    procedure VerifyItemRegister(AssemblyHeader: Record "Assembly Header")    var        SourceCodeSetup: Record "Source Code Setup";        ItemLedgerEntry: Record "Item Ledger Entry";        CapacityLedgerEntry: Record "Capacity Ledger Entry";        ValueEntry: Record "Value Entry";        ItemRegister: Record "Item Register";        ILEMin: Integer;        ILEMax: Integer;        ValueEntryMin: Integer;        ValueEntryMax: Integer;        CapEntryMin: Integer;        CapEntryMax: Integer;    begin        SourceCodeSetup.Get();        ItemLedgerEntry.Reset();        ItemLedgerEntry.SetRange("Order Type", ItemLedgerEntry."Order Type"::Assembly);        ItemLedgerEntry.SetRange("Order No.", AssemblyHeader."No.");        ItemLedgerEntry.SetRange("Posting Date", AssemblyHeader."Posting Date");        if ItemLedgerEntry.FindFirst() then            ILEMin := ItemLedgerEntry."Entry No.";        if ItemLedgerEntry.FindLast() then            ILEMax := ItemLedgerEntry."Entry No.";        ValueEntry.Reset();        ValueEntry.SetRange("Order Type", ValueEntry."Order Type"::Assembly);        ValueEntry.SetRange("Order No.", AssemblyHeader."No.");        ValueEntry.SetRange("Posting Date", AssemblyHeader."Posting Date");        ValueEntry.SetRange("Source Code", SourceCodeSetup.Assembly);        if ValueEntry.FindFirst() then            ValueEntryMin := ValueEntry."Entry No.";        if ValueEntry.FindLast() then            ValueEntryMax := ValueEntry."Entry No.";        CapacityLedgerEntry.Reset();        CapacityLedgerEntry.SetRange("Order Type", CapacityLedgerEntry."Order Type"::Assembly);        CapacityLedgerEntry.SetRange("Order No.", AssemblyHeader."No.");        CapacityLedgerEntry.SetRange("Posting Date", AssemblyHeader."Posting Date");        if CapacityLedgerEntry.FindFirst() then            CapEntryMin := CapacityLedgerEntry."Entry No.";        if CapacityLedgerEntry.FindLast() then            CapEntryMax := CapacityLedgerEntry."Entry No.";        ItemRegister.Reset();        ItemRegister.SetRange("From Entry No.", ILEMin);        ItemRegister.SetRange("To Entry No.", ILEMax);        ItemRegister.SetRange("From Value Entry No.", ValueEntryMin);        ItemRegister.SetRange("To Value Entry No.", ValueEntryMax);        ItemRegister.SetRange("From Capacity Entry No.", CapEntryMin);        ItemRegister.SetRange("To Capacity Entry No.", CapEntryMax);        ItemRegister.SetRange("Source Code", SourceCodeSetup.Assembly);        ItemRegister.FindFirst();    end;    procedure VerifyApplicationEntry(ItemLedgerEntry: Record "Item Ledger Entry")    var        ItemApplicationEntry: Record "Item Application Entry";    begin        ItemApplicationEntry.Reset();        ItemApplicationEntry.SetRange("Item Ledger Entry No.", ItemLedgerEntry."Entry No.");        ItemApplicationEntry.SetRange(Quantity, ItemLedgerEntry.Quantity);        case ItemLedgerEntry."Entry Type" of            ItemLedgerEntry."Entry Type"::"Assembly Consumption":                ItemApplicationEntry.SetRange("Outbound Item Entry No.", ItemLedgerEntry."Entry No.");            ItemLedgerEntry."Entry Type"::"Assembly Output":                begin                    ItemApplicationEntry.SetRange("Inbound Item Entry No.", ItemLedgerEntry."Entry No.");                    ItemApplicationEntry.SetRange("Outbound Item Entry No.", 0);                end;        end;        ItemApplicationEntry.FindFirst();        Assert.AreEqual(1, ItemApplicationEntry.Count,          'Wrong no. of application entries for ILE no ' + Format(ItemLedgerEntry."Entry No."));    end;    procedure VerifyApplicationEntryUndo(ItemLedgerEntry: Record "Item Ledger Entry")    var        ItemApplicationEntry: Record "Item Application Entry";    begin        ItemApplicationEntry.Reset();        case ItemLedgerEntry."Entry Type" of            ItemLedgerEntry."Entry Type"::"Assembly Consumption":                if ItemLedgerEntry.Correction then begin                    // Check reversed entry                    ItemApplicationEntry.SetRange("Item Ledger Entry No.", ItemLedgerEntry."Entry No.");                    ItemApplicationEntry.SetRange("Inbound Item Entry No.", ItemLedgerEntry."Entry No.");                    ItemApplicationEntry.SetRange(Quantity, ItemLedgerEntry.Quantity);                    ItemApplicationEntry.FindFirst();                    Assert.AreEqual(                      1, ItemApplicationEntry.Count, 'Wrong no. of application entries for ILE no ' + Format(ItemLedgerEntry."Entry No."));                end else begin                    // Check initial posted entry                    ItemApplicationEntry.SetRange("Item Ledger Entry No.", ItemLedgerEntry."Entry No.");                    ItemApplicationEntry.SetRange("Outbound Item Entry No.", ItemLedgerEntry."Entry No.");                    ItemApplicationEntry.SetRange(Quantity, ItemLedgerEntry.Quantity);                    ItemApplicationEntry.FindFirst();                    Assert.AreEqual(                      1, ItemApplicationEntry.Count, 'Wrong no. of application entries for ILE no ' + Format(ItemLedgerEntry."Entry No."));                end;            ItemLedgerEntry."Entry Type"::"Assembly Output":                if ItemLedgerEntry.Correction then begin                    // Check reversed entry                    ItemApplicationEntry.SetRange("Item Ledger Entry No.", ItemLedgerEntry."Entry No.");                    ItemApplicationEntry.SetRange("Outbound Item Entry No.", ItemLedgerEntry."Entry No.");                    ItemApplicationEntry.SetRange(Quantity, ItemLedgerEntry.Quantity);                    ItemApplicationEntry.FindFirst();                    Assert.AreEqual(                      1, ItemApplicationEntry.Count, 'Wrong no. of application entries for ILE no ' + Format(ItemLedgerEntry."Entry No."));                end else begin                    // Check initial posted entry                    ItemApplicationEntry.SetRange("Item Ledger Entry No.", ItemLedgerEntry."Entry No.");                    ItemApplicationEntry.SetRange("Outbound Item Entry No.", 0);                    ItemApplicationEntry.SetRange("Inbound Item Entry No.", ItemLedgerEntry."Entry No.");                    ItemApplicationEntry.SetRange(Quantity, ItemLedgerEntry.Quantity);                    Assert.AreEqual(                      1, ItemApplicationEntry.Count, 'Wrong no. of application entries for ILE no ' + Format(ItemLedgerEntry."Entry No."));                end;        end;    end;    procedure VerifyPostedLineComment(PostedAssemblyHeader: Record "Posted Assembly Header"; PostedAssemblyLineNo: Integer)    var        AssemblyCommentLine: Record "Assembly Comment Line";    begin        AssemblyCommentLine.Reset();        AssemblyCommentLine.SetRange("Document Type", AssemblyCommentLine."Document Type"::"Posted Assembly");        AssemblyCommentLine.SetRange("Document No.", PostedAssemblyHeader."No.");        AssemblyCommentLine.SetRange("Document Line No.", PostedAssemblyLineNo);        AssemblyCommentLine.SetRange(Comment, 'Order:' + PostedAssemblyHeader."Order No." + ', Line:' + Format(PostedAssemblyLineNo));        AssemblyCommentLine.FindFirst();        Assert.AreEqual(1, AssemblyCommentLine.Count, 'Wrong no. of comment lines.');    end;    procedure VerifyGLEntries(PostedAssemblyHeader: Record "Posted Assembly Header"; PerPostingGroup: Boolean)    var        GLEntry: Record "G/L Entry";        PostedAssemblyLine: Record "Posted Assembly Line";        InventoryPostingSetup: Record "Inventory Posting Setup";        GeneralPostingSetup: Record "General Posting Setup";        ValueEntry: Record "Value Entry";        TotalAmount: Decimal;        OutputDirectCost: Decimal;        ResDirectCost: Decimal;        ItemDirectCost: Decimal;        CompDirectCost: Decimal;        OutputIndirectCost: Decimal;        CompIndirectCost: Decimal;        MaterialVariance: Decimal;        CapacityVariance: Decimal;        CapOverhead: Decimal;        ManufOverhead: Decimal;    begin        // Get expected posting accounts for assembly item.        GetPostingSetup(GeneralPostingSetup, InventoryPostingSetup, PostedAssemblyHeader."Gen. Prod. Posting Group",          PostedAssemblyHeader."Inventory Posting Group", PostedAssemblyHeader."Location Code");        // Get output costs.        OutputDirectCost := GetValueEntriesAmount(PostedAssemblyHeader, ValueEntry."Item Ledger Entry Type"::"Assembly Output",            ValueEntry."Entry Type"::"Direct Cost", ValueEntry."Variance Type"::" ", PostedAssemblyHeader."Item No.", true);        OutputIndirectCost := GetValueEntriesAmount(PostedAssemblyHeader, ValueEntry."Item Ledger Entry Type"::"Assembly Output",            ValueEntry."Entry Type"::"Indirect Cost", ValueEntry."Variance Type"::" ", PostedAssemblyHeader."Item No.", true);        MaterialVariance := GetValueEntriesAmount(PostedAssemblyHeader, ValueEntry."Item Ledger Entry Type"::"Assembly Output",            ValueEntry."Entry Type"::Variance, ValueEntry."Variance Type"::Material, PostedAssemblyHeader."Item No.", true);        CapacityVariance := GetValueEntriesAmount(PostedAssemblyHeader, ValueEntry."Item Ledger Entry Type"::"Assembly Output",            ValueEntry."Entry Type"::Variance, ValueEntry."Variance Type"::Capacity, PostedAssemblyHeader."Item No.", true);        CapOverhead := GetValueEntriesAmount(PostedAssemblyHeader, ValueEntry."Item Ledger Entry Type"::"Assembly Output",            ValueEntry."Entry Type"::Variance, ValueEntry."Variance Type"::"Capacity Overhead", PostedAssemblyHeader."Item No.", true);        ManufOverhead := GetValueEntriesAmount(PostedAssemblyHeader, ValueEntry."Item Ledger Entry Type"::"Assembly Output",            ValueEntry."Entry Type"::Variance, ValueEntry."Variance Type"::"Manufacturing Overhead", PostedAssemblyHeader."Item No.", true);        // Get component costs.        ResDirectCost :=          GetValueEntriesAmount(PostedAssemblyHeader, ValueEntry."Item Ledger Entry Type"::" ",            ValueEntry."Entry Type"::"Direct Cost", ValueEntry."Variance Type"::" ", '', true);        ItemDirectCost :=          GetValueEntriesAmount(PostedAssemblyHeader, ValueEntry."Item Ledger Entry Type"::"Assembly Consumption",            ValueEntry."Entry Type"::"Direct Cost", ValueEntry."Variance Type"::" ", '', true);        // Get consumption direct and indirect costs.        CompDirectCost := -ItemDirectCost + ResDirectCost;        CompIndirectCost :=          GetValueEntriesAmount(PostedAssemblyHeader, ValueEntry."Item Ledger Entry Type"::"Assembly Consumption",            ValueEntry."Entry Type"::"Indirect Cost", ValueEntry."Variance Type"::" ", '', true) +          GetValueEntriesAmount(PostedAssemblyHeader, ValueEntry."Item Ledger Entry Type"::" ",            ValueEntry."Entry Type"::"Indirect Cost", ValueEntry."Variance Type"::" ", '', true);        // Verify GL entries.        // Verify Inventory Account for output.        VerifyGLEntry(PostedAssemblyHeader."No.", InventoryPostingSetup."Inventory Account", PostedAssemblyHeader."Posting Date",          OutputDirectCost + OutputIndirectCost + MaterialVariance + CapacityVariance + CapOverhead + ManufOverhead, '<>');        // Verify Material variance account for header.        VerifyGLEntry(PostedAssemblyHeader."No.", InventoryPostingSetup."Material Variance Account", PostedAssemblyHeader."Posting Date",          -MaterialVariance, '<>');        // Verify Capacity variance account for header.        VerifyGLEntry(PostedAssemblyHeader."No.", InventoryPostingSetup."Capacity Variance Account", PostedAssemblyHeader."Posting Date",          -CapacityVariance, '<>');        // Verify Capacity overhead variance account for header.        VerifyGLEntry(PostedAssemblyHeader."No.", InventoryPostingSetup."Cap. Overhead Variance Account", PostedAssemblyHeader.          "Posting Date",          -CapOverhead, '<>');        // Verify Mfg. overhead variance account for header.        VerifyGLEntry(PostedAssemblyHeader."No.", InventoryPostingSetup."Mfg. Overhead Variance Account", PostedAssemblyHeader.          "Posting Date",          -ManufOverhead, '<>');        // Verify Inventory Adjustment account, both header and component.        VerifyGLEntry(PostedAssemblyHeader."No.", GeneralPostingSetup."Inventory Adjmt. Account", PostedAssemblyHeader."Posting Date",          CompDirectCost + CompIndirectCost - OutputDirectCost, '<>');        // Verify Overhead applied account, both header and component.        VerifyGLEntry(PostedAssemblyHeader."No.", GeneralPostingSetup."Overhead Applied Account", PostedAssemblyHeader."Posting Date",          -OutputIndirectCost - CompIndirectCost, '<>');        // Verify consumption entries.        PostedAssemblyLine.Reset();        PostedAssemblyLine.SetRange("Document No.", PostedAssemblyHeader."No.");        PostedAssemblyLine.SetRange("Order No.", PostedAssemblyHeader."Order No.");        PostedAssemblyLine.SetRange(Type, PostedAssemblyLine.Type::Item);        if PostedAssemblyLine.FindFirst() then            GetPostingSetup(GeneralPostingSetup, InventoryPostingSetup, PostedAssemblyLine."Gen. Prod. Posting Group",              PostedAssemblyLine."Inventory Posting Group", PostedAssemblyLine."Location Code");        // Verify cost aggregation under the document no. for 'Per posting group' option in posting.        ValueEntry.SetRange("Item No.", PostedAssemblyLine."No.");        ValueEntry.SetRange("Variant Code", PostedAssemblyLine."Variant Code");        ValueEntry.SetRange("Location Code", PostedAssemblyLine."Location Code");        ValueEntry.SetRange("Item Ledger Entry Type", ValueEntry."Item Ledger Entry Type"::"Positive Adjmt.");        ValueEntry.SetRange("Entry Type", ValueEntry."Entry Type"::"Direct Cost");        if ValueEntry.FindFirst() and PerPostingGroup then            VerifyGLEntry(PostedAssemblyHeader."No.", GeneralPostingSetup."Inventory Adjmt. Account", ValueEntry."Posting Date",              -ValueEntry."Cost Amount (Actual)", '<>');        // Verify Inventory account for item consumption.        VerifyGLEntry(PostedAssemblyHeader."No.", InventoryPostingSetup."Inventory Account", PostedAssemblyHeader."Posting Date",          ItemDirectCost, '<>');        // Verify Direct Cost account for resource consumption.        VerifyGLEntry(PostedAssemblyHeader."No.", GeneralPostingSetup."Direct Cost Applied Account", PostedAssemblyHeader."Posting Date",          -ResDirectCost, '<>');        // Check G/L transaction is balanced.        GLEntry.SetCurrentKey("Document No.", "Posting Date");        GLEntry.SetRange("Document No.", PostedAssemblyHeader."No.");        GLEntry.SetRange("Posting Date", PostedAssemblyHeader."Posting Date");        GLEntry.FindSet();        repeat            TotalAmount += GLEntry.Amount;        until GLEntry.Next() = 0;        Assert.AreEqual(0, TotalAmount, 'Transaction must be balanced:' + PostedAssemblyHeader."No.");    end;    procedure VerifyGLEntry(DocumentNo: Code[20]; AccountNo: Code[20]; PostingDate: Date; Amount: Decimal; Sign: Text[30])    var        GLEntry: Record "G/L Entry";        ActualAmount: Decimal;    begin        ActualAmount := 0;        GLEntry.Reset();        GLEntry.SetRange("Document No.", DocumentNo);        GLEntry.SetRange("G/L Account No.", AccountNo);        GLEntry.SetRange("Posting Date", PostingDate);        GLEntry.SetFilter(Amount, Sign + '%1', 0);        if GLEntry.FindSet() then            repeat                ActualAmount += GLEntry.Amount;            until GLEntry.Next() = 0;        Assert.AreNearlyEqual(Amount, ActualAmount, LibraryERM.GetAmountRoundingPrecision(), 'Account:' + AccountNo);    end;    procedure VerifyLineAdjustmentEntry(PostedAssemblyLine: Record "Posted Assembly Line"; FinalAdjSource: Option)    var        Item: Record Item;        ValueEntry: Record "Value Entry";        UnitCost: Decimal;        Overhead: Decimal;        IndirectCost: Decimal;        AdjUnitCost: Decimal;    begin        Item.Get(PostedAssemblyLine."No.");        GetCostInformation(UnitCost, Overhead, IndirectCost, "BOM Component Type"::Item,          PostedAssemblyLine."No.", PostedAssemblyLine."Variant Code", PostedAssemblyLine."Location Code");        FindLineValueEntries(ValueEntry, PostedAssemblyLine, ValueEntry."Entry Type"::"Direct Cost",          ValueEntry."Item Ledger Entry Type"::"Assembly Consumption");        ValueEntry.SetRange(Adjustment, true);        if NeedsAdjustment(AdjUnitCost, Item, PostedAssemblyLine, FinalAdjSource, UnitCost) then begin            Assert.AreEqual(1, ValueEntry.Count, 'Different than 1 entry for comp. item no. ' + PostedAssemblyLine."No.");            ValueEntry.FindFirst();            Assert.AreNearlyEqual(Abs(AdjUnitCost), Abs(ValueEntry."Cost per Unit"),              LibraryERM.GetAmountRoundingPrecision(), 'Wrong unit cost for adj.');            // Currently system's absolute error for "Cost Amount (Actual)" depends on ValueEntry."Valued Quantity" and GLSetup."Unit-amount rounding precision"            Assert.AreNearlyEqual(              ValueEntry."Cost Amount (Actual)", ValueEntry."Cost per Unit" * ValueEntry."Valued Quantity",              LibraryERM.GetUnitAmountRoundingPrecision() * ValueEntry."Valued Quantity",              'Wrong adj. entry cost amount.');        end else begin            // For differences in adj. amount less than 0.01, eliminate rounding adjustment entries.            ValueEntry.SetFilter("Cost Amount (Actual)", '>%1', LibraryERM.GetAmountRoundingPrecision());            Assert.IsTrue(ValueEntry.IsEmpty, 'Unexpected adj. entries for comp item no. ' + PostedAssemblyLine."No.");        end;    end;    procedure VerifyAdjustmentEntries(AssemblyHeader: Record "Assembly Header"; FinalAdjSource: Option)    var        PostedAssemblyHeader: Record "Posted Assembly Header";        PostedAssemblyLine: Record "Posted Assembly Line";        Item: Record Item;        StockkeepingUnit: Record "Stockkeeping Unit";        AdjAmount: Decimal;        VarianceAmount: Decimal;    begin        Commit();        PostedAssemblyHeader.Reset();        PostedAssemblyHeader.SetRange("Order No.", AssemblyHeader."No.");        PostedAssemblyHeader.SetRange("Item No.", AssemblyHeader."Item No.");        PostedAssemblyHeader.SetRange("Variant Code", AssemblyHeader."Variant Code");        PostedAssemblyHeader.FindFirst();        PostedAssemblyLine.Reset();        PostedAssemblyLine.SetRange("Document No.", PostedAssemblyHeader."No.");        PostedAssemblyLine.SetRange("Order No.", AssemblyHeader."No.");        PostedAssemblyLine.SetRange(Type, PostedAssemblyLine.Type::Item);        PostedAssemblyLine.SetFilter("No.", '<>%1', AssemblyHeader."Item No.");  // Skip validation for auto consumption.        if PostedAssemblyLine.FindSet() then            repeat                VerifyLineAdjustmentEntry(PostedAssemblyLine, FinalAdjSource);            until PostedAssemblyLine.Next() = 0;        GetAdjAmounts(VarianceAmount, AdjAmount, PostedAssemblyHeader);        VerifyHeaderAdjustmentEntry(PostedAssemblyHeader, AdjAmount);        Item.Get(AssemblyHeader."Item No.");        if Item."Costing Method" = Item."Costing Method"::Standard then begin            if StockkeepingUnit.Get(PostedAssemblyHeader."Location Code", Item."No.", PostedAssemblyHeader."Variant Code") then                VarianceAmount := VarianceAmount - PostedAssemblyHeader."Cost Amount" + Item."Standard Cost" * PostedAssemblyHeader.Quantity;            VerifyHeaderVarianceEntry(PostedAssemblyHeader, VarianceAmount);        end;    end;    procedure VerifyHeaderAdjustmentEntry(PostedAssemblyHeader: Record "Posted Assembly Header"; AdjAmount: Decimal)    var        ValueEntry: Record "Value Entry";    begin        FindHeaderValueEntries(ValueEntry, PostedAssemblyHeader, ValueEntry."Entry Type"::"Direct Cost",          ValueEntry."Item Ledger Entry Type"::"Assembly Output");        ValueEntry.SetRange(Adjustment, true);        if AdjAmount <> 0 then begin            ValueEntry.FindFirst();            Assert.AreEqual(1, ValueEntry.Count, 'Wrong no. of adjustment entries for header.');            Assert.AreNearlyEqual(-AdjAmount, ValueEntry."Cost Amount (Actual)",              LibraryERM.GetAmountRoundingPrecision(), 'Wrong header adj. entry cost amount.');            // Currently system's absolute error for "Cost Amount (Actual)" depends on ValueEntry."Valued Quantity" and GLSetup."Unit-amount rounding precision"            Assert.AreNearlyEqual(              ValueEntry."Cost Amount (Actual)", ValueEntry."Cost per Unit" * ValueEntry."Valued Quantity",              LibraryERM.GetUnitAmountRoundingPrecision() * ValueEntry."Valued Quantity",              'Wrong header adj. entry cost per unit.');        end else            Assert.IsTrue(ValueEntry.IsEmpty, 'Unexpected adj. entries for header ' + PostedAssemblyHeader."No.");    end;    procedure VerifyHeaderVarianceEntry(PostedAssemblyHeader: Record "Posted Assembly Header"; VarianceAmount: Decimal)    var        ValueEntry: Record "Value Entry";        ActualVarianceAmount: Decimal;    begin        FindHeaderValueEntries(ValueEntry, PostedAssemblyHeader, ValueEntry."Entry Type"::Variance,          ValueEntry."Item Ledger Entry Type"::"Assembly Output");        ValueEntry.SetRange(Adjustment, true);        if VarianceAmount <> 0 then begin            ValueEntry.FindSet();            ActualVarianceAmount := 0;            repeat                ActualVarianceAmount += ValueEntry."Cost Amount (Actual)";            until ValueEntry.Next() = 0;            Assert.AreNearlyEqual(VarianceAmount, ActualVarianceAmount, LibraryERM.GetAmountRoundingPrecision(),              'Wrong variance entry cost amount for header.');        end else            Assert.IsTrue(ValueEntry.IsEmpty, 'Unexpected variance entry for ' + PostedAssemblyHeader."No.");    end;    procedure VerifyIndirectCostEntries(AssemblyHeader: Record "Assembly Header")    var        ValueEntry: Record "Value Entry";        PostedAssemblyLine: Record "Posted Assembly Line";        PostedAssemblyHeader: Record "Posted Assembly Header";        Resource: Record Resource;        IndirectCostAmount: Decimal;        UnitCost: Decimal;        Overhead: Decimal;        IndirectCost: Decimal;        ActualIndirectCostAmount: Decimal;    begin        GetCostInformation(UnitCost, Overhead, IndirectCost, PostedAssemblyLine.Type::Item, AssemblyHeader."Item No.",          AssemblyHeader."Variant Code", AssemblyHeader."Location Code");        PostedAssemblyHeader.Reset();        PostedAssemblyHeader.SetRange("Order No.", AssemblyHeader."No.");        PostedAssemblyHeader.FindFirst();        // Output indirect cost.        IndirectCostAmount :=          GetValueEntriesAmount(PostedAssemblyHeader, ValueEntry."Item Ledger Entry Type"::"Assembly Output",            ValueEntry."Entry Type"::"Direct Cost", ValueEntry."Variance Type"::" ", PostedAssemblyHeader."Item No.", false) *          IndirectCost / 100;        ActualIndirectCostAmount :=          GetValueEntriesAmount(PostedAssemblyHeader, ValueEntry."Item Ledger Entry Type"::"Assembly Output",            ValueEntry."Entry Type"::"Indirect Cost", ValueEntry."Variance Type"::" ", PostedAssemblyHeader."Item No.", false);        Assert.AreNearlyEqual(IndirectCostAmount, ActualIndirectCostAmount, LibraryERM.GetAmountRoundingPrecision(),          'Wrong Output indirect cost');        // Resource component indirect cost.        PostedAssemblyLine.Reset();        PostedAssemblyLine.SetRange("Document No.", PostedAssemblyHeader."No.");        PostedAssemblyLine.SetRange("Order No.", PostedAssemblyHeader."Order No.");        PostedAssemblyLine.SetRange(Type, PostedAssemblyLine.Type::Resource);        if PostedAssemblyLine.FindSet() then            repeat                FindLineValueEntries(ValueEntry, PostedAssemblyLine, ValueEntry."Entry Type"::"Direct Cost",                  ValueEntry."Item Ledger Entry Type"::" ");                ValueEntry.FindFirst();                Resource.Get(PostedAssemblyLine."No.");                IndirectCostAmount := ValueEntry."Cost Amount (Actual)" * Resource."Indirect Cost %" / 100;                FindLineValueEntries(ValueEntry, PostedAssemblyLine, ValueEntry."Entry Type"::"Indirect Cost",                  ValueEntry."Item Ledger Entry Type"::" ");                if ValueEntry.FindFirst() then                    Assert.AreNearlyEqual(IndirectCostAmount, ValueEntry."Cost Amount (Actual)", LibraryERM.GetAmountRoundingPrecision(),                      'Wrong component indirect cost');            until PostedAssemblyLine.Next() = 0;    end;    procedure VerifyPartialPosting(AssemblyHeader: Record "Assembly Header"; HeaderQtyFactor: Decimal)    var        AssemblyLine: Record "Assembly Line";    begin        if HeaderQtyFactor <> 100 then begin            AssemblyHeader.Get(AssemblyHeader."Document Type", AssemblyHeader."No.");            AssemblyHeader.TestField("Quantity to Assemble", AssemblyHeader.Quantity * (100 - HeaderQtyFactor) / 100);            AssemblyHeader.TestField("Remaining Quantity", AssemblyHeader."Quantity to Assemble");            AssemblyLine.SetRange("Document Type", AssemblyHeader."Document Type");            AssemblyLine.SetRange("Document No.", AssemblyHeader."No.");            AssemblyLine.FindSet();            repeat                if AssemblyLine."Resource Usage Type" <> AssemblyLine."Resource Usage Type"::Fixed then begin                    Assert.AreNearlyEqual(AssemblyHeader.Quantity * AssemblyHeader."Qty. per Unit of Measure" *                      AssemblyLine."Quantity per", AssemblyLine.Quantity,                      LibraryERM.GetUnitAmountRoundingPrecision(), 'Wrong partial line quantity.');                    Assert.AreNearlyEqual(                      AssemblyHeader."Remaining Quantity" * AssemblyHeader."Qty. per Unit of Measure" * AssemblyLine."Quantity per",                      AssemblyLine."Quantity to Consume",                      LibraryERM.GetUnitAmountRoundingPrecision(), 'Wrong partial line qty. to consume.');                end else begin                    Assert.AreNearlyEqual(AssemblyLine."Quantity per", AssemblyLine.Quantity,                      LibraryERM.GetUnitAmountRoundingPrecision(), 'Wrong partial line qty. - fixed.');                    Assert.AreNearlyEqual(                      AssemblyLine.Quantity - AssemblyLine."Consumed Quantity", AssemblyLine."Quantity to Consume",                      LibraryERM.GetUnitAmountRoundingPrecision(), 'Wrong partial line qty. to consume - fixed.');                end;            until AssemblyLine.Next() = 0;        end;    end;    procedure VerifyPostedAssemblyHeader(var TempAssemblyLine: Record "Assembly Line" temporary; AssemblyHeader: Record "Assembly Header"; AssembledQty: Decimal)    var        PostedAssemblyLine: Record "Posted Assembly Line";        PostedAssemblyHeader: Record "Posted Assembly Header";    begin        PostedAssemblyHeader.Reset();        PostedAssemblyHeader.SetRange("Order No.", AssemblyHeader."No.");        PostedAssemblyHeader.SetRange("Item No.", AssemblyHeader."Item No.");        PostedAssemblyHeader.SetRange("Variant Code", AssemblyHeader."Variant Code");        PostedAssemblyHeader.SetRange(Description, AssemblyHeader.Description);        PostedAssemblyHeader.SetRange("Inventory Posting Group", AssemblyHeader."Inventory Posting Group");        PostedAssemblyHeader.SetRange("Gen. Prod. Posting Group", AssemblyHeader."Gen. Prod. Posting Group");        PostedAssemblyHeader.SetRange("Location Code", AssemblyHeader."Location Code");        PostedAssemblyHeader.SetRange("Shortcut Dimension 1 Code", AssemblyHeader."Shortcut Dimension 1 Code");        PostedAssemblyHeader.SetRange("Shortcut Dimension 2 Code", AssemblyHeader."Shortcut Dimension 2 Code");        PostedAssemblyHeader.SetRange("Posting Date", AssemblyHeader."Posting Date");        PostedAssemblyHeader.SetRange(Quantity, AssembledQty);        PostedAssemblyHeader.SetRange("Unit Cost", AssemblyHeader."Unit Cost");        PostedAssemblyHeader.SetRange("Unit of Measure Code", AssemblyHeader."Unit of Measure Code");        PostedAssemblyHeader.SetRange("Dimension Set ID", AssemblyHeader."Dimension Set ID");        Assert.AreEqual(1, PostedAssemblyHeader.Count, 'Wrong no. of posted assembly order records!');        PostedAssemblyHeader.FindFirst();        Assert.AreNearlyEqual(AssemblyHeader."Cost Amount" * AssembledQty / AssemblyHeader.Quantity, PostedAssemblyHeader."Cost Amount",          LibraryERM.GetAmountRoundingPrecision(), 'Wrong posted cost amount.');        if TempAssemblyLine.FindSet() then            repeat                PostedAssemblyLine.Reset();                PostedAssemblyLine.SetRange("Document No.", PostedAssemblyHeader."No.");                PostedAssemblyLine.SetRange("Order Line No.", TempAssemblyLine."Line No.");                PostedAssemblyLine.SetRange(Type, TempAssemblyLine.Type);                PostedAssemblyLine.SetRange("No.", TempAssemblyLine."No.");                PostedAssemblyLine.SetRange("Variant Code", TempAssemblyLine."Variant Code");                PostedAssemblyLine.SetRange(Description, TempAssemblyLine.Description);                PostedAssemblyLine.SetRange("Resource Usage Type", TempAssemblyLine."Resource Usage Type");                PostedAssemblyLine.SetRange("Location Code", TempAssemblyLine."Location Code");                PostedAssemblyLine.SetRange("Shortcut Dimension 1 Code", TempAssemblyLine."Shortcut Dimension 1 Code");                PostedAssemblyLine.SetRange("Shortcut Dimension 2 Code", TempAssemblyLine."Shortcut Dimension 2 Code");                PostedAssemblyLine.SetRange(Quantity, TempAssemblyLine."Quantity to Consume");                PostedAssemblyLine.SetRange("Unit of Measure Code", TempAssemblyLine."Unit of Measure Code");                PostedAssemblyLine.SetRange("Dimension Set ID", TempAssemblyLine."Dimension Set ID");                PostedAssemblyLine.SetRange("Unit Cost", TempAssemblyLine."Unit Cost");                Assert.AreEqual(1, PostedAssemblyLine.Count, 'Wrong no. of posted lines for ' + TempAssemblyLine."No.");                PostedAssemblyLine.FindFirst();                // Do not check cost amount for comment lines.                if TempAssemblyLine.Type <> TempAssemblyLine.Type::" " then                    Assert.AreNearlyEqual(                      TempAssemblyLine."Cost Amount" * TempAssemblyLine."Quantity to Consume" / TempAssemblyLine.Quantity,                      PostedAssemblyLine."Cost Amount", LibraryERM.GetAmountRoundingPrecision(), 'Wrong posted line cost amount.');            until TempAssemblyLine.Next() = 0;    end;    procedure VerifyPostedComments(AssemblyHeader: Record "Assembly Header")    var        PostedAssemblyLine: Record "Posted Assembly Line";        PostedAssemblyHeader: Record "Posted Assembly Header";    begin        FindPostedAssemblyHeaders(PostedAssemblyHeader, AssemblyHeader);        PostedAssemblyHeader.FindFirst();        VerifyPostedLineComment(PostedAssemblyHeader, 0);        FindPostedAssemblyLines(PostedAssemblyLine, PostedAssemblyHeader);        if PostedAssemblyLine.FindSet() then            repeat                VerifyPostedLineComment(PostedAssemblyHeader, PostedAssemblyLine."Line No.");            until PostedAssemblyLine.Next() = 0;    end;    procedure VerifyWarehouseEntries(var TempAssemblyHeader: Record "Assembly Header" temporary; var TempAssemblyLine: Record "Assembly Line" temporary; IsUndo: Boolean)    var        WarehouseEntry: Record "Warehouse Entry";        SourceCodeSetup: Record "Source Code Setup";    begin        SourceCodeSetup.Get();        WarehouseEntry.Reset();        WarehouseEntry.SetRange("Source Code", SourceCodeSetup.Assembly);        WarehouseEntry.SetRange("Source No.", TempAssemblyHeader."No.");        WarehouseEntry.SetRange("Registering Date", TempAssemblyHeader."Posting Date");        WarehouseEntry.SetRange("User ID", UserId);        WarehouseEntry.SetRange("Variant Code", TempAssemblyHeader."Variant Code");        WarehouseEntry.SetRange("Unit of Measure Code", TempAssemblyHeader."Unit of Measure Code");        if IsUndo then begin            WarehouseEntry.SetRange(Quantity, -TempAssemblyHeader."Quantity to Assemble");            WarehouseEntry.SetRange("Entry Type", WarehouseEntry."Entry Type"::"Negative Adjmt.")        end else begin            WarehouseEntry.SetRange("Entry Type", WarehouseEntry."Entry Type"::"Positive Adjmt.");            WarehouseEntry.SetRange(Quantity, TempAssemblyHeader."Quantity to Assemble");        end;        WarehouseEntry.SetRange("Location Code", TempAssemblyHeader."Location Code");        WarehouseEntry.SetRange("Bin Code", TempAssemblyHeader."Bin Code");        WarehouseEntry.SetRange(          "Zone Code", LibraryWarehouse.GetZoneForBin(TempAssemblyHeader."Location Code", TempAssemblyHeader."Bin Code"));        WarehouseEntry.SetRange("Item No.", TempAssemblyHeader."Item No.");        Assert.AreEqual(1, WarehouseEntry.Count, 'Incorect number of warehouse entries for assembly ' + TempAssemblyHeader."No.");        // Verify warehouse entries for components        TempAssemblyLine.Reset();        TempAssemblyLine.SetRange(Type, TempAssemblyLine.Type::Item);        TempAssemblyLine.FindSet();        repeat            WarehouseEntry.Reset();            WarehouseEntry.SetRange("Source Code", SourceCodeSetup.Assembly);            WarehouseEntry.SetRange("Source No.", TempAssemblyHeader."No.");            WarehouseEntry.SetRange("Registering Date", TempAssemblyHeader."Posting Date");            WarehouseEntry.SetRange("User ID", UserId);            WarehouseEntry.SetRange("Variant Code", TempAssemblyLine."Variant Code");            WarehouseEntry.SetRange("Unit of Measure Code", TempAssemblyLine."Unit of Measure Code");            if IsUndo then begin                WarehouseEntry.SetRange(Quantity, TempAssemblyLine."Quantity to Consume");                WarehouseEntry.SetRange("Entry Type", WarehouseEntry."Entry Type"::"Positive Adjmt.")            end else begin                WarehouseEntry.SetRange(Quantity, -TempAssemblyLine."Quantity to Consume");                WarehouseEntry.SetRange("Entry Type", WarehouseEntry."Entry Type"::"Negative Adjmt.");            end;            WarehouseEntry.SetRange("Location Code", TempAssemblyLine."Location Code");            WarehouseEntry.SetRange("Bin Code", TempAssemblyLine."Bin Code");            WarehouseEntry.SetRange("Item No.", TempAssemblyLine."No.");            Assert.AreEqual(1, WarehouseEntry.Count, 'Incorrect number of warehouse entries for assembly line ' + TempAssemblyLine."No.");        until TempAssemblyLine.Next() = 0;    end;    procedure VerifyBinContent(LocationCode: Code[20]; BinCode: Code[20]; ItemNo: Code[20]; VariantCode: Code[10]; UOMCode: Code[10]; Quantity: Decimal)    var        BinContent: Record "Bin Content";    begin        BinContent.Reset();        BinContent.SetRange("Location Code", LocationCode);        BinContent.SetRange("Bin Code", BinCode);        BinContent.SetRange("Item No.", ItemNo);        BinContent.SetRange("Variant Code", VariantCode);        BinContent.SetRange("Unit of Measure Code", UOMCode);        if BinContent.FindFirst() then begin            BinContent.CalcFields(Quantity);            BinContent.TestField(Quantity, Quantity);        end else            Assert.AreEqual(Quantity, 0, 'Incorrect Bin Code Qty for Item: ' + ItemNo + ' in Bin: ' + BinCode);    end;    procedure VerifyBinContents(var TempAssemblyHeader: Record "Assembly Header" temporary; var TempAssemblyLine: Record "Assembly Line" temporary; AdditionalQty: Decimal)    begin        // This function has to be called after the AO has been posted and no other "output" qtities exist in inventory        // Verify bin content for header assembly item does not exist        VerifyBinContent(          TempAssemblyHeader."Location Code", TempAssemblyHeader."Bin Code", TempAssemblyHeader."Item No.",          TempAssemblyHeader."Variant Code", TempAssemblyHeader."Unit of Measure Code", 0);        // Verify bin contents for components        TempAssemblyLine.Reset();        TempAssemblyLine.SetRange(Type, TempAssemblyLine.Type::Item);        TempAssemblyLine.FindSet();        repeat            VerifyBinContent(              TempAssemblyLine."Location Code", TempAssemblyLine."Bin Code", TempAssemblyLine."No.", TempAssemblyLine."Variant Code",              TempAssemblyLine."Unit of Measure Code",              AdditionalQty + TempAssemblyLine.Quantity);        until TempAssemblyLine.Next() = 0;    end;    procedure SetLinkToLines(AsmHeader: Record "Assembly Header"; var AsmLine: Record "Assembly Line")    begin        AsmLine.SetRange("Document Type", AsmHeader."Document Type");        AsmLine.SetRange("Document No.", AsmHeader."No.");    end;    procedure EarliestAvailableDate(AsmHeader: Record "Assembly Header"; var AssemblyLine: Record "Assembly Line"; var ReturnQtyAvailable: Decimal; var EarliestDueDate: Date)    var        Item: Record Item;        ReqLine: Record "Requisition Line";        LeadTimeMgt: Codeunit "Lead-Time Management";        LineAvailabilityDate: Date;        LineStartingDate: Date;        EarliestEndingDate: Date;        EarliestStartingDate: Date;        LineProportion: Decimal;        Proportion: Decimal;        GrossRequirement: Decimal;        ScheduledRcpt: Decimal;        ExpectedInventory: Decimal;        LineAbleToAssemble: Decimal;        LineInventory: Decimal;    begin        SetLinkToLines(AsmHeader, AssemblyLine);        AssemblyLine.SetRange(Type, AssemblyLine.Type::Item);        AssemblyLine.SetFilter("No.", '<>%1', '');        AssemblyLine.SetFilter("Quantity per", '<>%1', 0);        Proportion := AsmHeader."Remaining Quantity";        if AssemblyLine.FindFirst() then            repeat                AssemblyLine.CalcAvailToAssemble(                  AsmHeader,                  Item,                  GrossRequirement,                  ScheduledRcpt,                  ExpectedInventory,                  LineInventory,                  LineAvailabilityDate,                  LineAbleToAssemble);                LineProportion := LineAbleToAssemble;                if LineProportion < Proportion then                    Proportion := LineProportion;                if LineAvailabilityDate > 0D then begin                    LineStartingDate := CalcDate(AssemblyLine."Lead-Time Offset", LineAvailabilityDate);                    if LineStartingDate > EarliestStartingDate then                        EarliestStartingDate := LineStartingDate; // latest of all line starting dates                end;            until AssemblyLine.Next() = 0;        ReturnQtyAvailable := Proportion;        EarliestDueDate := 0D;        if EarliestStartingDate > 0D then begin            EarliestEndingDate :=              // earliest starting date + lead time calculation              LeadTimeMgt.GetPlannedEndingDate(                AsmHeader."Item No.", AsmHeader."Location Code", AsmHeader."Variant Code",                '', LeadTimeMgt.ManufacturingLeadTime(AsmHeader."Item No.", AsmHeader."Location Code", AsmHeader."Variant Code"),                ReqLine."Ref. Order Type"::Assembly, EarliestStartingDate);            EarliestDueDate :=              // earliest ending date + (default) safety lead time              LeadTimeMgt.GetPlannedDueDate(                AsmHeader."Item No.", AsmHeader."Location Code", AsmHeader."Variant Code",                EarliestEndingDate, '', ReqLine."Ref. Order Type"::Assembly);        end;    end;    procedure ComponentsAvailable(AssemblyHeader: Record "Assembly Header"): Boolean    var        AssemblyLine: Record "Assembly Line";        ItemCheckAvail: Codeunit "Item-Check Avail.";        Inventory: Decimal;        GrossRequirement: Decimal;        ReservedRequirement: Decimal;        ScheduledReceipts: Decimal;        ReservedReceipts: Decimal;        QtyAvailToMake: Decimal;        EarliestAvailableDateX: Date;    begin        SetLinkToLines(AssemblyHeader, AssemblyLine);        ItemCheckAvail.AsmOrderCalculate(AssemblyHeader, Inventory,          GrossRequirement, ReservedRequirement, ScheduledReceipts, ReservedReceipts);        EarliestAvailableDate(AssemblyHeader, AssemblyLine, QtyAvailToMake, EarliestAvailableDateX);        exit(QtyAvailToMake >= AssemblyHeader."Remaining Quantity");    end;    procedure LineCount(AssemblyHeader: Record "Assembly Header"): Integer    var        AssemblyLine: Record "Assembly Line";    begin        SetLinkToLines(AssemblyHeader, AssemblyLine);        exit(AssemblyLine.Count);    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeInsertInventoryPostingSetup(var InventoryPostingSetup: Record "Inventory Posting Setup")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCreateMultipleLvlTreeOnCreateBOM(var Item: Record Item; NoOfComps: Integer; var BOMCreated: Boolean)    begin    end;}