test/OpcUa_Test_JSON_Non_Reversible.ttcn - titan/titan.ProtocolModules.OPC_UA - Git at Google

 /////////////////////////////////////////////////////////////////////////////////////
 // Copyright (c) 2017-2018  Ericsson AB
 // All rights reserved. This program and the accompanying materials
 // are made available under the terms of the Eclipse Public License v1.0
 // which accompanies this distribution, and is available at
 // http://www.eclipse.org/legal/epl-v10.html
 /////////////////////////////////////////////////////////////////////////////////////
 // Contributors:
 // Akos Makovics
 //
 //  File:         OpcUa_Test_JSON.ttcn
 //  Rev:          <RnXnn>
 //  Prodnr:       CNL113861
 /////////////////////////////////////////////////////////////////////////////////////

 module OpcUa_Test_JSON_Non_Reversible {

   import from OpcUa_Types_JSON_Non_Reversible all;
   import from OpcUa_Functions_JSON_Non_Reversible all;
   import from OpcUa_Templates_JSON_Non_Reversible all;

   type component MyComp {}

   /////////////////////////////////////////////////////////////
   //                                                         //
   //             Encoders and Decoders for testing           //
   //                   different structures                  //
   //                                                         //
   /////////////////////////////////////////////////////////////

   external function enc_ObjectAttributes (in ObjectAttributes msg) return octetstring
     with { extension "prototype(convert) encode(JSON)" }

   external function dec_ObjectAttributes (in octetstring p_oct, out ObjectAttributes msg) return integer
     with {extension "prototype(backtrack) decode (JSON) errorbehavior(ALL:WARNING)"}

   external function enc_VariableAttributes (in VariableAttributes msg) return octetstring
     with { extension "prototype(convert) encode(JSON)" }

   external function dec_VariableAttributes (in octetstring p_oct, out VariableAttributes msg) return integer
     with {extension "prototype(backtrack) decode (JSON) errorbehavior(ALL:WARNING)"}

   external function enc_MethodAttributes (in MethodAttributes msg) return octetstring
     with { extension "prototype(convert) encode(JSON)" }

   external function dec_MethodAttributes (in octetstring p_oct, out MethodAttributes msg) return integer
     with {extension "prototype(backtrack) decode (JSON) errorbehavior(ALL:WARNING)"}

   external function enc_ObjectTypeAttributes (in ObjectTypeAttributes msg) return octetstring
     with { extension "prototype(convert) encode(JSON)" }

   external function dec_ObjectTypeAttributes (in octetstring p_oct, out ObjectTypeAttributes msg) return integer
     with {extension "prototype(backtrack) decode (JSON) errorbehavior(ALL:WARNING)"}

   external function enc_VariableTypeAttributes (in VariableTypeAttributes msg) return octetstring
     with { extension "prototype(convert) encode(JSON)" }

   external function dec_VariableTypeAttributes (in octetstring p_oct, out VariableTypeAttributes msg) return integer
     with {extension "prototype(backtrack) decode (JSON) errorbehavior(ALL:WARNING)"}

   external function enc_ReferenceTypeAttributes (in ReferenceTypeAttributes msg) return octetstring
     with { extension "prototype(convert) encode(JSON)" }

   external function dec_ReferenceTypeAttributes (in octetstring p_oct, out ReferenceTypeAttributes msg) return integer
     with {extension "prototype(backtrack) decode (JSON) errorbehavior(ALL:WARNING)"}

   external function enc_DataTypeAttributes (in DataTypeAttributes msg) return octetstring
     with { extension "prototype(convert) encode(JSON)" }

   external function dec_DataTypeAttributes (in octetstring p_oct, out DataTypeAttributes msg) return integer
     with {extension "prototype(backtrack) decode (JSON) errorbehavior(ALL:WARNING)"}

   external function enc_ViewAttributes (in ViewAttributes msg) return octetstring
     with { extension "prototype(convert) encode(JSON)" }

   external function dec_ViewAttributes (in octetstring p_oct, out ViewAttributes msg) return integer
     with {extension "prototype(backtrack) decode (JSON) errorbehavior(ALL:WARNING)"}

   external function enc_DataValue (in DataValue msg) return octetstring
     with { extension "prototype(convert) encode(JSON)" }

   external function dec_DataValue (in octetstring p_oct, out DataValue msg) return integer
     with {extension "prototype(backtrack) decode (JSON) errorbehavior(ALL:WARNING)"}

   external function enc_NodeId (in NodeId msg) return octetstring
     with { extension "prototype(convert) encode(JSON)" }

   external function dec_NodeId (in octetstring p_oct, out NodeId msg) return integer
     with {extension "prototype(backtrack) decode (JSON) errorbehavior(ALL:WARNING)"}

   external function enc_ExpandedNodeId (in ExpandedNodeId msg) return octetstring
     with { extension "prototype(convert) encode(JSON)" }

   external function dec_ExpandedNodeId (in octetstring p_oct, out ExpandedNodeId msg) return integer
     with {extension "prototype(backtrack) decode (JSON) errorbehavior(ALL:WARNING)"}

   function f_EncDecDec_ObjectAttributes () runs on MyComp {
     log("==========================================================================");
     log("f_EncDecDec_VariableAttributes Enter");

     var ObjectAttributes v_orig := {
       EncodingMask := 0,
       displayName := {
         locale := "en",
         text := "glish"
       },
       description := omit,
       eventNotifier := 0,
       writeMask := 0,
       userWriteMask := 0
     };

     f_ObjectAttributes_PreProcess(v_orig);

     var ObjectAttributes v_dec;
     var octetstring v_encoded := enc_ObjectAttributes(v_orig);

     if (dec_ObjectAttributes(v_encoded, v_dec) == -1) {
       setverdict(fail, "Failed to decode message chunk!");
       return;
     }

     f_ObjectAttributes_PostProcess(v_dec);
     f_ObjectAttributes_PreProcess(v_dec);

     if (v_encoded == enc_ObjectAttributes(v_dec)) {
       setverdict(pass);
     } else {
       setverdict(fail);
     }
   }

   function f_EncDecDec_VariableAttributes () runs on MyComp {
     log("==========================================================================");
     log("f_EncDecDec_VariableAttributes Enter");

     var VariableAttributes v_orig := {
       EncodingMask := 0,
       displayName := {
         locale := "en",
         text := "glish"
       },
       description := omit,
       Value := 0,
       dataType := omit,
       valueRank := 0,
       arrayDimensions := omit,
       accessLevel := 0,
       userAccessLevel := 0,
       minimumSamplingInterval := omit,
       historizing := omit,
       writeMask := 0,
       userWriteMask := 0
     };

     f_VariableAttributes_PreProcess(v_orig);

     var VariableAttributes v_dec;
     var octetstring v_encoded := enc_VariableAttributes(v_orig);

     if (dec_VariableAttributes(v_encoded, v_dec) == -1) {
       setverdict(fail, "Failed to decode message chunk!");
       return;
     }

     f_VariableAttributes_PostProcess(v_dec);
     f_VariableAttributes_PreProcess(v_dec);

     if (v_encoded == enc_VariableAttributes(v_dec)) {
       setverdict(pass);
     } else {
       setverdict(fail);
     }
   }

   function f_EncDecDec_MethodAttributes () runs on MyComp {
     log("==========================================================================");
     log("f_EncDecDec_MethodAttributes Enter");

     var MethodAttributes v_orig := {
       EncodingMask := 0,
       displayName := {
         locale := "en",
         text := "glish"
       },
       description := omit,
       executable := false,
       userExecutable := false,
       writeMask := 0,
       userWriteMask := 0
     };

     f_MethodAttributes_PreProcess(v_orig);

     var MethodAttributes v_dec;
     var octetstring v_encoded := enc_MethodAttributes(v_orig);

     if (dec_MethodAttributes(v_encoded, v_dec) == -1) {
       setverdict(fail, "Failed to decode message chunk!");
       return;
     }

     f_MethodAttributes_PostProcess(v_dec);
     f_MethodAttributes_PreProcess(v_dec);

     if (v_encoded == enc_MethodAttributes(v_dec)) {
       setverdict(pass);
     } else {
       setverdict(fail);
     }
   }

   function f_EncDecDec_ObjectTypeAttributes () runs on MyComp {
     log("==========================================================================");
     log("f_EncDecDec_MethodAttributes Enter");

     var ObjectTypeAttributes v_orig := {
       EncodingMask := 0,
       displayName := {
         locale := "en",
         text := "glish"
       },
       description := omit,
       isAbstract := false,
       writeMask := 0,
       userWriteMask := 0
     };

     f_ObjectTypeAttributes_PreProcess(v_orig);

     var ObjectTypeAttributes v_dec;
     var octetstring v_encoded := enc_ObjectTypeAttributes(v_orig);

     if (dec_ObjectTypeAttributes(v_encoded, v_dec) == -1) {
       setverdict(fail, "Failed to decode message chunk!");
       return;
     }

     f_ObjectTypeAttributes_PostProcess(v_dec);
     f_ObjectTypeAttributes_PreProcess(v_dec);

     if (v_encoded == enc_ObjectTypeAttributes(v_dec)) {
       setverdict(pass);
     } else {
       setverdict(fail);
     }
   }

   function f_EncDecDec_VariableTypeAttributes () runs on MyComp {
     log("==========================================================================");
     log("f_EncDecDec_MethodAttributes Enter");

     var VariableTypeAttributes v_orig := {
       EncodingMask := 0,
       displayName := {
         locale := "en",
         text := "glish"
       },
       description := omit,
       Value := 0,
       dataType := omit,
       valueRank := 0,
       arrayDimensions := omit,
       isAbstract := false,
       writeMask := 0,
       userWriteMask := 0
     };

     f_VariableTypeAttributes_PreProcess(v_orig);

     var VariableTypeAttributes v_dec;
     var octetstring v_encoded := enc_VariableTypeAttributes(v_orig);

     if (dec_VariableTypeAttributes(v_encoded, v_dec) == -1) {
       setverdict(fail, "Failed to decode message chunk!");
       return;
     }

     f_VariableTypeAttributes_PostProcess(v_dec);
     f_VariableTypeAttributes_PreProcess(v_dec);

     if (v_encoded == enc_VariableTypeAttributes(v_dec)) {
       setverdict(pass);
     } else {
       setverdict(fail);
     }
   }

   function f_EncDecDec_ReferenceTypeAttributes () runs on MyComp {
     log("==========================================================================");
     log("f_EncDecDec_MethodAttributes Enter");

     var ReferenceTypeAttributes v_orig := {
       EncodingMask := 0,
       displayName := {
         locale := "en",
         text := "glish"
       },
       description := omit,
       isAbstract := true,
       symmetric := true,
       inverseName := omit,
       writeMask := 0,
       userWriteMask := 0
     };

     f_ReferenceTypeAttributes_PreProcess(v_orig);

     var ReferenceTypeAttributes v_dec;
     var octetstring v_encoded := enc_ReferenceTypeAttributes(v_orig);

     if (dec_ReferenceTypeAttributes(v_encoded, v_dec) == -1) {
       setverdict(fail, "Failed to decode message chunk!");
       return;
     }

     f_ReferenceTypeAttributes_PostProcess(v_dec);
     f_ReferenceTypeAttributes_PreProcess(v_dec);

     if (v_encoded == enc_ReferenceTypeAttributes(v_dec)) {
       setverdict(pass);
     } else {
       setverdict(fail);
     }
   }

   function f_EncDecDec_DataTypeAttributes () runs on MyComp {
     log("==========================================================================");
     log("f_EncDecDec_MethodAttributes Enter");

     var DataTypeAttributes v_orig := {
       EncodingMask := 0,
       displayName := {
         locale := "en",
         text := "glish"
       },
       description := omit,
       isAbstract := true,
       writeMask := 0,
       userWriteMask := 0
     };

     f_DataTypeAttributes_PreProcess(v_orig);

     var DataTypeAttributes v_dec;
     var octetstring v_encoded := enc_DataTypeAttributes(v_orig);

     if (dec_DataTypeAttributes(v_encoded, v_dec) == -1) {
       setverdict(fail, "Failed to decode message chunk!");
       return;
     }

     f_DataTypeAttributes_PostProcess(v_dec);
     f_DataTypeAttributes_PreProcess(v_dec);

     if (v_encoded == enc_DataTypeAttributes(v_dec)) {
       setverdict(pass);
     } else {
       setverdict(fail);
     }
   }

   function f_EncDecDec_ViewAttributes () runs on MyComp {
     log("==========================================================================");
     log("f_EncDecDec_MethodAttributes Enter");

     var ViewAttributes v_orig := {
       EncodingMask := 0,
       displayName := {
         locale := "en",
         text := "glish"
       },
       description := omit,
       containsNoLoops := true,
       eventNotifier := 0,
       writeMask := 0,
       userWriteMask := 0
     };

     f_ViewAttributes_PreProcess(v_orig);

     var ViewAttributes v_dec;
     var octetstring v_encoded := enc_ViewAttributes(v_orig);

     if (dec_ViewAttributes(v_encoded, v_dec) == -1) {
       setverdict(fail, "Failed to decode message chunk!");
       return;
     }

     f_ViewAttributes_PostProcess(v_dec);
     f_ViewAttributes_PreProcess(v_dec);

     if (v_encoded == enc_ViewAttributes(v_dec)) {
       setverdict(pass);
     } else {
       setverdict(fail);
     }
   }

   function f_EncDecDec_DataValue () runs on MyComp {
     log("==========================================================================");
     log("f_EncDecDec_MethodAttributes Enter");

     var DataValue v_orig := {
       EncodingMask := 0,
       Value := omit,
       Status := omit,
       SourceTimeStamp := omit,
       SourcePicoSecond := 0,
       ServerTimestamp := omit,
       ServerPicoSeconds := 0
     };

     f_DataValue_PreProcess(v_orig);

     var DataValue v_dec;
     var octetstring v_encoded := enc_DataValue(v_orig);

     if (dec_DataValue(v_encoded, v_dec) == -1) {
       setverdict(fail, "Failed to decode message chunk!");
       return;
     }

     f_DataValue_PostProcess(v_dec);
     f_DataValue_PreProcess(v_dec);

     if (v_encoded == enc_DataValue(v_dec)) {
       setverdict(pass);
     } else {
       setverdict(fail);
     }
   }

   function f_EncDec_NodeIdUInt32() {
     log("==========================================================================");
     log("f_EncDec_NodeIdUInt32 Enter");

     var NodeId v_orig := valueof(tr_NodeId_UInt32(0, omit));

     var NodeId v_dec;
     var octetstring v_encoded := enc_NodeId(v_orig);

     if (dec_NodeId(v_encoded, v_dec) == -1) {
       setverdict(fail, "Failed to decode message chunk!");
       return;
     }

     if (v_dec.IdType != 0) {
       setverdict(fail, "IdType is invalid!");
     } else {
       v_dec.IdType := omit;
     }

     if (v_encoded == enc_NodeId(v_dec)) {
       setverdict(pass);
     } else {
       setverdict(fail);
     }
   }

   function f_EncDec_NodeIdGuid() {
     log("==========================================================================");
     log("f_EncDec_NodeIdGuid Enter");

     var NodeId v_orig := valueof(tr_NodeId_GUID("Hello", omit));

     var NodeId v_dec;
     var octetstring v_encoded := enc_NodeId(v_orig);

     if (dec_NodeId(v_encoded, v_dec) == -1) {
       setverdict(fail, "Failed to decode message chunk!");
       return;
     }

     if (v_encoded == enc_NodeId(v_dec)) {
       setverdict(pass);
     } else {
       setverdict(fail);
     }
   }

   function f_EncDec_ExpandedNodeIdByteString() {
     log("==========================================================================");
     log("f_EncDec_NodeIdGuid Enter");

     var ExpandedNodeId v_orig := valueof(tr_ExpandedNodeId_ByteString("Hello", omit, omit));

     var ExpandedNodeId v_dec;
     var octetstring v_encoded := enc_ExpandedNodeId(v_orig);

     if (dec_ExpandedNodeId(v_encoded, v_dec) == -1) {
       setverdict(fail, "Failed to decode message chunk!");
       return;
     }

     if (v_encoded == enc_ExpandedNodeId(v_dec)) {
       setverdict(pass);
     } else {
       setverdict(fail);
     }
   }

   function f_EncDec_MessageTypes(MessageTypes v_orig) {
     var MessageTypes v_dec;
     var octetstring v_encoded := enc_MessageTypes(v_orig);

     if (dec_MessageTypes(v_encoded, v_dec) == -1) {
       setverdict(fail, "Failed to decode message chunk!");
       return;
     }

     if (v_encoded == enc_MessageTypes(v_dec)) {
       setverdict(pass);
     } else {
       setverdict(fail);
     }
   }

   testcase tc_EncDecDec_ObjectAttributes() runs on MyComp {
     f_EncDecDec_ObjectAttributes();
   }

   testcase tc_EncDecDec_VariableAttributes() runs on MyComp {
     f_EncDecDec_VariableAttributes();
   }

   testcase tc_EncDecDec_MethodAttributes() runs on MyComp {
     f_EncDecDec_MethodAttributes();
   }

   testcase tc_EncDecDec_ObjectTypeAttributes() runs on MyComp {
     f_EncDecDec_ObjectTypeAttributes();
   }

   testcase tc_EncDecDec_VariableTypeAttributes() runs on MyComp {
     f_EncDecDec_VariableTypeAttributes();
   }

   testcase tc_EncDecDec_ReferenceTypeAttributes() runs on MyComp {
     f_EncDecDec_ReferenceTypeAttributes();
   }

   testcase tc_EncDecDec_DataTypeAttributes() runs on MyComp {
     f_EncDecDec_DataTypeAttributes();
   }

   testcase tc_EncDecDec_ViewAttributes() runs on MyComp {
     f_EncDecDec_ViewAttributes();
   }

   testcase tc_EncDecDec_DataValue() runs on MyComp {
     f_EncDecDec_DataValue();
   }

   testcase tc_EncDecDec_NodeIdUInt32() runs on MyComp {
     f_EncDec_NodeIdUInt32();
   }

   testcase tc_EncDecDec_NodeIdGuid() runs on MyComp {
     f_EncDec_NodeIdGuid();
   }

   testcase tc_EncDecDec_ExpandedNodeIdByteString() runs on MyComp {
     f_EncDec_ExpandedNodeIdByteString();
   }

   testcase tc_EncDecDec_HelloMessage() runs on MyComp {
     var MessageTypes v_orig := {
       HelloMessage := {
         messageType := HelloHeaderMsgType,
         chunkType := FinalChunk,
         messageSize := 0,
         version := 1,
         receiveBufferSize := 256,
         sendBufferSize := 256,
         maxMessageSize := 200,
         maxChunkCount := 2,
         endPointUrl := "EndPoint"
       }
     }

     v_orig.HelloMessage.messageSize := f_CalculateSize(v_orig);

     f_EncDec_MessageTypes(v_orig);
   }

   testcase tc_EncDecDec_AckMessage() runs on MyComp {
     var MessageTypes v_orig := {
       AckMessage := {
       messageType := HelloHeaderMsgType,
       chunkType := FinalChunk,
       messageSize := 0,
       version := 1,
       receiveBufferSize := 256,
       sendBufferSize := 256,
       maxMessageSize := 200,
       maxChunkCount := 2
       }
     }

     v_orig.AckMessage.messageSize := f_CalculateSize(v_orig);

     f_EncDec_MessageTypes(v_orig);
   }

   testcase tc_EncDecDec_ErrorMessage() runs on MyComp {
     var MessageTypes v_orig := {
       ErrorMessage := {
       messageType := HelloHeaderMsgType,
       chunkType := FinalChunk,
       messageSize := 0,
       errorCode := 1234,
       reason := "reason"
       }
     }

     v_orig.ErrorMessage.messageSize := f_CalculateSize(v_orig);

     f_EncDec_MessageTypes(v_orig);
   }

   testcase tc_EncDecDec_ReverseHelloMessage() runs on MyComp {
     var MessageTypes v_orig := {
       ReverseHelloMessage := {
       messageType := HelloHeaderMsgType,
       chunkType := FinalChunk,
       messageSize := 0,
       serverUri := "Server",
       endPointUrl := "url"
       }
     }

     v_orig.ReverseHelloMessage.messageSize := f_CalculateSize(v_orig);

     f_EncDec_MessageTypes(v_orig);
   }

   testcase tc_EncDec_OpenSecureChannelRequest() runs on MyComp {
     var MessageTypes v_orig := {
       OpenSecureChannelRequest := {
         messageType := OpenSecureChannelMsgType,
         chunkType := FinalChunk,
         messageSize := 0,

         securityChannelId := 1,
         securePolicyUri := {2, 3, 4},
         senderCertificate := {55, 6, 7},
         receiverCertificateThumbprint := {0, 1},
         sequenceHeader := {
           SequenceNumber := 1,
           RequestId := 0
         },

         encodingByte := 22,
         namespaceIndex := 0,
         nodeValue := OpenSecureChannelRequestNodeId,

         requestHeader := {
           authenticationToken := valueof(tr_NodeId_String("Id", omit)),
           timestamp := "2018.04.13",
           requestHandle := 2,
           returnDiagnostics := 1,
           auditEntryId := "tmp",
           timeoutHint := 0,
           additionalHeader := {
             typeId := valueof(tr_ExpandedNodeId_GUID("AS", tr_Namespace_1, "namespace")),
             Value := 1
           }
         },
         clientProtocolVersion := 1,
         requestType := ISSUE_0,
         securityMode := NONE_1,
         clientNonce := "client",
         requestedLifetime := 60
       }
     }

     v_orig.OpenSecureChannelRequest.messageSize := f_CalculateSize(v_orig);

     f_EncDec_MessageTypes(v_orig);
   }

   testcase tc_EncDec_GetEndpointsResponse() runs on MyComp {
     var MessageTypes v_orig := {
       GetEndpointsResponse := {
         messageType := ServicesMsgType,
         chunkType := FinalChunk,
         messageSize := 0,

         securityChannelId := 1,
         securityTokenId := 2,
         sequenceHeader := {
           SequenceNumber := 2,
           RequestId := 0
         },

         encodingByte := 22,
         namespaceIndex := 0,
         nodeValue := GetEndpointsResponseNodeId,

         responseHeader := {
           timestamp := "2018.04.13",
           requestHandle := 3,
           serviceResult := omit,
           serviceDiagnostics := {
             SymbolicId := 1,
             NamespaceUri := 0,
             Locale := 1,
             LocalizedText := 22,
             AdditionalInfo := "Hello",
             InnerStatusCode := {
               Code := 1,
               Symbol := "Error"
             },
             InnerDiagnosticInfo := omit
           },
           stringTable := {"Hello", "Bye"},
           additionalHeader := {
             typeId := valueof(tr_ExpandedNodeId_GUID("AS", tr_Namespace("namespace"), omit)),
             Value := 1
           }
         },
         Endpoints := {
           {
             endpointUrl := "URL",
             server := {
               applicationUri := "uri",
               productUri := "product",
               applicationName := {
                 locale := "Locale",
                 text := "Text"
               },
               applicationType := CLIENT_1,
               gatewayServerUri := "gatewayServerUri",
               discoveryProfileUri := "discoveryProfileUri",
               discoveryUrls := {"discoveryUrls", "discoveryUrls"}
             },
             serverCertificate := "001010",
             securityMode := NONE_1,
             securityPolicyUri := "discoveryUrls",
             userIdentityTokens := {
               {
                 policyId := "Policy",
                 tokenType := USERNAME_1,
                 issuedTokenType := "ASD",
                 issuerEndpointUrl := "URL",
                 securityPolicyUri := "URI"
               }
             },
             transportProfileUri := "URI",
             securityLevel := 0
           }
         }
       }
     }

     v_orig.GetEndpointsResponse.messageSize := f_CalculateSize(v_orig);

     f_EncDec_MessageTypes(v_orig);
   }

   control {
     //Encode and decode structures with test encoders
     execute(tc_EncDecDec_ObjectAttributes());
     execute(tc_EncDecDec_VariableAttributes());
     execute(tc_EncDecDec_MethodAttributes());
     execute(tc_EncDecDec_ObjectTypeAttributes());
     execute(tc_EncDecDec_VariableTypeAttributes());
     execute(tc_EncDecDec_ReferenceTypeAttributes());
     execute(tc_EncDecDec_DataTypeAttributes());
     execute(tc_EncDecDec_ViewAttributes());
     execute(tc_EncDecDec_DataValue());
     execute(tc_EncDecDec_NodeIdUInt32());
     execute(tc_EncDecDec_NodeIdGuid());
     execute(tc_EncDecDec_ExpandedNodeIdByteString());

     //Encode and decode messages
     execute(tc_EncDecDec_HelloMessage());
     execute(tc_EncDecDec_AckMessage());
     execute(tc_EncDecDec_ErrorMessage());
     execute(tc_EncDecDec_ReverseHelloMessage());
     execute(tc_EncDec_OpenSecureChannelRequest());
     execute(tc_EncDec_GetEndpointsResponse());
   }
 }  with { encode "JSON" }
	/////////////////////////////////////////////////////////////////////////////////////
	// Copyright (c) 2017-2018 Ericsson AB
	// All rights reserved. This program and the accompanying materials
	// are made available under the terms of the Eclipse Public License v1.0
	// which accompanies this distribution, and is available at
	// http://www.eclipse.org/legal/epl-v10.html
	/////////////////////////////////////////////////////////////////////////////////////
	// Contributors:
	// Akos Makovics
	//
	// File: OpcUa_Test_JSON.ttcn
	// Rev: <RnXnn>
	// Prodnr: CNL113861
	/////////////////////////////////////////////////////////////////////////////////////

	module OpcUa_Test_JSON_Non_Reversible {

	import from OpcUa_Types_JSON_Non_Reversible all;
	import from OpcUa_Functions_JSON_Non_Reversible all;
	import from OpcUa_Templates_JSON_Non_Reversible all;

	type component MyComp {}

	/////////////////////////////////////////////////////////////
	// //
	// Encoders and Decoders for testing //
	// different structures //
	// //
	/////////////////////////////////////////////////////////////

	external function enc_ObjectAttributes (in ObjectAttributes msg) return octetstring
	with { extension "prototype(convert) encode(JSON)" }

	external function dec_ObjectAttributes (in octetstring p_oct, out ObjectAttributes msg) return integer
	with {extension "prototype(backtrack) decode (JSON) errorbehavior(ALL:WARNING)"}

	external function enc_VariableAttributes (in VariableAttributes msg) return octetstring
	with { extension "prototype(convert) encode(JSON)" }

	external function dec_VariableAttributes (in octetstring p_oct, out VariableAttributes msg) return integer
	with {extension "prototype(backtrack) decode (JSON) errorbehavior(ALL:WARNING)"}

	external function enc_MethodAttributes (in MethodAttributes msg) return octetstring
	with { extension "prototype(convert) encode(JSON)" }

	external function dec_MethodAttributes (in octetstring p_oct, out MethodAttributes msg) return integer
	with {extension "prototype(backtrack) decode (JSON) errorbehavior(ALL:WARNING)"}

	external function enc_ObjectTypeAttributes (in ObjectTypeAttributes msg) return octetstring
	with { extension "prototype(convert) encode(JSON)" }

	external function dec_ObjectTypeAttributes (in octetstring p_oct, out ObjectTypeAttributes msg) return integer
	with {extension "prototype(backtrack) decode (JSON) errorbehavior(ALL:WARNING)"}

	external function enc_VariableTypeAttributes (in VariableTypeAttributes msg) return octetstring
	with { extension "prototype(convert) encode(JSON)" }

	external function dec_VariableTypeAttributes (in octetstring p_oct, out VariableTypeAttributes msg) return integer
	with {extension "prototype(backtrack) decode (JSON) errorbehavior(ALL:WARNING)"}

	external function enc_ReferenceTypeAttributes (in ReferenceTypeAttributes msg) return octetstring
	with { extension "prototype(convert) encode(JSON)" }

	external function dec_ReferenceTypeAttributes (in octetstring p_oct, out ReferenceTypeAttributes msg) return integer
	with {extension "prototype(backtrack) decode (JSON) errorbehavior(ALL:WARNING)"}

	external function enc_DataTypeAttributes (in DataTypeAttributes msg) return octetstring
	with { extension "prototype(convert) encode(JSON)" }

	external function dec_DataTypeAttributes (in octetstring p_oct, out DataTypeAttributes msg) return integer
	with {extension "prototype(backtrack) decode (JSON) errorbehavior(ALL:WARNING)"}

	external function enc_ViewAttributes (in ViewAttributes msg) return octetstring
	with { extension "prototype(convert) encode(JSON)" }

	external function dec_ViewAttributes (in octetstring p_oct, out ViewAttributes msg) return integer
	with {extension "prototype(backtrack) decode (JSON) errorbehavior(ALL:WARNING)"}

	external function enc_DataValue (in DataValue msg) return octetstring
	with { extension "prototype(convert) encode(JSON)" }

	external function dec_DataValue (in octetstring p_oct, out DataValue msg) return integer
	with {extension "prototype(backtrack) decode (JSON) errorbehavior(ALL:WARNING)"}

	external function enc_NodeId (in NodeId msg) return octetstring
	with { extension "prototype(convert) encode(JSON)" }

	external function dec_NodeId (in octetstring p_oct, out NodeId msg) return integer
	with {extension "prototype(backtrack) decode (JSON) errorbehavior(ALL:WARNING)"}

	external function enc_ExpandedNodeId (in ExpandedNodeId msg) return octetstring
	with { extension "prototype(convert) encode(JSON)" }

	external function dec_ExpandedNodeId (in octetstring p_oct, out ExpandedNodeId msg) return integer
	with {extension "prototype(backtrack) decode (JSON) errorbehavior(ALL:WARNING)"}

	function f_EncDecDec_ObjectAttributes () runs on MyComp {
	log("==========================================================================");
	log("f_EncDecDec_VariableAttributes Enter");

	var ObjectAttributes v_orig := {
	EncodingMask := 0,
	displayName := {
	locale := "en",
	text := "glish"
	},
	description := omit,
	eventNotifier := 0,
	writeMask := 0,
	userWriteMask := 0
	};

	f_ObjectAttributes_PreProcess(v_orig);

	var ObjectAttributes v_dec;
	var octetstring v_encoded := enc_ObjectAttributes(v_orig);

	if (dec_ObjectAttributes(v_encoded, v_dec) == -1) {
	setverdict(fail, "Failed to decode message chunk!");
	return;
	}

	f_ObjectAttributes_PostProcess(v_dec);
	f_ObjectAttributes_PreProcess(v_dec);

	if (v_encoded == enc_ObjectAttributes(v_dec)) {
	setverdict(pass);
	} else {
	setverdict(fail);
	}
	}

	function f_EncDecDec_VariableAttributes () runs on MyComp {
	log("==========================================================================");
	log("f_EncDecDec_VariableAttributes Enter");

	var VariableAttributes v_orig := {
	EncodingMask := 0,
	displayName := {
	locale := "en",
	text := "glish"
	},
	description := omit,
	Value := 0,
	dataType := omit,
	valueRank := 0,
	arrayDimensions := omit,
	accessLevel := 0,
	userAccessLevel := 0,
	minimumSamplingInterval := omit,
	historizing := omit,
	writeMask := 0,
	userWriteMask := 0
	};

	f_VariableAttributes_PreProcess(v_orig);

	var VariableAttributes v_dec;
	var octetstring v_encoded := enc_VariableAttributes(v_orig);

	if (dec_VariableAttributes(v_encoded, v_dec) == -1) {
	setverdict(fail, "Failed to decode message chunk!");
	return;
	}

	f_VariableAttributes_PostProcess(v_dec);
	f_VariableAttributes_PreProcess(v_dec);

	if (v_encoded == enc_VariableAttributes(v_dec)) {
	setverdict(pass);
	} else {
	setverdict(fail);
	}
	}

	function f_EncDecDec_MethodAttributes () runs on MyComp {
	log("==========================================================================");
	log("f_EncDecDec_MethodAttributes Enter");

	var MethodAttributes v_orig := {
	EncodingMask := 0,
	displayName := {
	locale := "en",
	text := "glish"
	},
	description := omit,
	executable := false,
	userExecutable := false,
	writeMask := 0,
	userWriteMask := 0
	};

	f_MethodAttributes_PreProcess(v_orig);

	var MethodAttributes v_dec;
	var octetstring v_encoded := enc_MethodAttributes(v_orig);

	if (dec_MethodAttributes(v_encoded, v_dec) == -1) {
	setverdict(fail, "Failed to decode message chunk!");
	return;
	}

	f_MethodAttributes_PostProcess(v_dec);
	f_MethodAttributes_PreProcess(v_dec);

	if (v_encoded == enc_MethodAttributes(v_dec)) {
	setverdict(pass);
	} else {
	setverdict(fail);
	}
	}

	function f_EncDecDec_ObjectTypeAttributes () runs on MyComp {
	log("==========================================================================");
	log("f_EncDecDec_MethodAttributes Enter");

	var ObjectTypeAttributes v_orig := {
	EncodingMask := 0,
	displayName := {
	locale := "en",
	text := "glish"
	},
	description := omit,
	isAbstract := false,
	writeMask := 0,
	userWriteMask := 0
	};

	f_ObjectTypeAttributes_PreProcess(v_orig);

	var ObjectTypeAttributes v_dec;
	var octetstring v_encoded := enc_ObjectTypeAttributes(v_orig);

	if (dec_ObjectTypeAttributes(v_encoded, v_dec) == -1) {
	setverdict(fail, "Failed to decode message chunk!");
	return;
	}

	f_ObjectTypeAttributes_PostProcess(v_dec);
	f_ObjectTypeAttributes_PreProcess(v_dec);

	if (v_encoded == enc_ObjectTypeAttributes(v_dec)) {
	setverdict(pass);
	} else {
	setverdict(fail);
	}
	}

	function f_EncDecDec_VariableTypeAttributes () runs on MyComp {
	log("==========================================================================");
	log("f_EncDecDec_MethodAttributes Enter");

	var VariableTypeAttributes v_orig := {
	EncodingMask := 0,
	displayName := {
	locale := "en",
	text := "glish"
	},
	description := omit,
	Value := 0,
	dataType := omit,
	valueRank := 0,
	arrayDimensions := omit,
	isAbstract := false,
	writeMask := 0,
	userWriteMask := 0
	};

	f_VariableTypeAttributes_PreProcess(v_orig);

	var VariableTypeAttributes v_dec;
	var octetstring v_encoded := enc_VariableTypeAttributes(v_orig);

	if (dec_VariableTypeAttributes(v_encoded, v_dec) == -1) {
	setverdict(fail, "Failed to decode message chunk!");
	return;
	}

	f_VariableTypeAttributes_PostProcess(v_dec);
	f_VariableTypeAttributes_PreProcess(v_dec);

	if (v_encoded == enc_VariableTypeAttributes(v_dec)) {
	setverdict(pass);
	} else {
	setverdict(fail);
	}
	}

	function f_EncDecDec_ReferenceTypeAttributes () runs on MyComp {
	log("==========================================================================");
	log("f_EncDecDec_MethodAttributes Enter");

	var ReferenceTypeAttributes v_orig := {
	EncodingMask := 0,
	displayName := {
	locale := "en",
	text := "glish"
	},
	description := omit,
	isAbstract := true,
	symmetric := true,
	inverseName := omit,
	writeMask := 0,
	userWriteMask := 0
	};

	f_ReferenceTypeAttributes_PreProcess(v_orig);

	var ReferenceTypeAttributes v_dec;
	var octetstring v_encoded := enc_ReferenceTypeAttributes(v_orig);

	if (dec_ReferenceTypeAttributes(v_encoded, v_dec) == -1) {
	setverdict(fail, "Failed to decode message chunk!");
	return;
	}

	f_ReferenceTypeAttributes_PostProcess(v_dec);
	f_ReferenceTypeAttributes_PreProcess(v_dec);

	if (v_encoded == enc_ReferenceTypeAttributes(v_dec)) {
	setverdict(pass);
	} else {
	setverdict(fail);
	}
	}

	function f_EncDecDec_DataTypeAttributes () runs on MyComp {
	log("==========================================================================");
	log("f_EncDecDec_MethodAttributes Enter");

	var DataTypeAttributes v_orig := {
	EncodingMask := 0,
	displayName := {
	locale := "en",
	text := "glish"
	},
	description := omit,
	isAbstract := true,
	writeMask := 0,
	userWriteMask := 0
	};

	f_DataTypeAttributes_PreProcess(v_orig);

	var DataTypeAttributes v_dec;
	var octetstring v_encoded := enc_DataTypeAttributes(v_orig);

	if (dec_DataTypeAttributes(v_encoded, v_dec) == -1) {
	setverdict(fail, "Failed to decode message chunk!");
	return;
	}

	f_DataTypeAttributes_PostProcess(v_dec);
	f_DataTypeAttributes_PreProcess(v_dec);

	if (v_encoded == enc_DataTypeAttributes(v_dec)) {
	setverdict(pass);
	} else {
	setverdict(fail);
	}
	}

	function f_EncDecDec_ViewAttributes () runs on MyComp {
	log("==========================================================================");
	log("f_EncDecDec_MethodAttributes Enter");

	var ViewAttributes v_orig := {
	EncodingMask := 0,
	displayName := {
	locale := "en",
	text := "glish"
	},
	description := omit,
	containsNoLoops := true,
	eventNotifier := 0,
	writeMask := 0,
	userWriteMask := 0
	};

	f_ViewAttributes_PreProcess(v_orig);

	var ViewAttributes v_dec;
	var octetstring v_encoded := enc_ViewAttributes(v_orig);

	if (dec_ViewAttributes(v_encoded, v_dec) == -1) {
	setverdict(fail, "Failed to decode message chunk!");
	return;
	}

	f_ViewAttributes_PostProcess(v_dec);
	f_ViewAttributes_PreProcess(v_dec);

	if (v_encoded == enc_ViewAttributes(v_dec)) {
	setverdict(pass);
	} else {
	setverdict(fail);
	}
	}

	function f_EncDecDec_DataValue () runs on MyComp {
	log("==========================================================================");
	log("f_EncDecDec_MethodAttributes Enter");

	var DataValue v_orig := {
	EncodingMask := 0,
	Value := omit,
	Status := omit,
	SourceTimeStamp := omit,
	SourcePicoSecond := 0,
	ServerTimestamp := omit,
	ServerPicoSeconds := 0
	};

	f_DataValue_PreProcess(v_orig);

	var DataValue v_dec;
	var octetstring v_encoded := enc_DataValue(v_orig);

	if (dec_DataValue(v_encoded, v_dec) == -1) {
	setverdict(fail, "Failed to decode message chunk!");
	return;
	}

	f_DataValue_PostProcess(v_dec);
	f_DataValue_PreProcess(v_dec);

	if (v_encoded == enc_DataValue(v_dec)) {
	setverdict(pass);
	} else {
	setverdict(fail);
	}
	}

	function f_EncDec_NodeIdUInt32() {
	log("==========================================================================");
	log("f_EncDec_NodeIdUInt32 Enter");

	var NodeId v_orig := valueof(tr_NodeId_UInt32(0, omit));

	var NodeId v_dec;
	var octetstring v_encoded := enc_NodeId(v_orig);

	if (dec_NodeId(v_encoded, v_dec) == -1) {
	setverdict(fail, "Failed to decode message chunk!");
	return;
	}

	if (v_dec.IdType != 0) {
	setverdict(fail, "IdType is invalid!");
	} else {
	v_dec.IdType := omit;
	}

	if (v_encoded == enc_NodeId(v_dec)) {
	setverdict(pass);
	} else {
	setverdict(fail);
	}
	}

	function f_EncDec_NodeIdGuid() {
	log("==========================================================================");
	log("f_EncDec_NodeIdGuid Enter");

	var NodeId v_orig := valueof(tr_NodeId_GUID("Hello", omit));

	var NodeId v_dec;
	var octetstring v_encoded := enc_NodeId(v_orig);

	if (dec_NodeId(v_encoded, v_dec) == -1) {
	setverdict(fail, "Failed to decode message chunk!");
	return;
	}

	if (v_encoded == enc_NodeId(v_dec)) {
	setverdict(pass);
	} else {
	setverdict(fail);
	}
	}

	function f_EncDec_ExpandedNodeIdByteString() {
	log("==========================================================================");
	log("f_EncDec_NodeIdGuid Enter");

	var ExpandedNodeId v_orig := valueof(tr_ExpandedNodeId_ByteString("Hello", omit, omit));

	var ExpandedNodeId v_dec;
	var octetstring v_encoded := enc_ExpandedNodeId(v_orig);

	if (dec_ExpandedNodeId(v_encoded, v_dec) == -1) {
	setverdict(fail, "Failed to decode message chunk!");
	return;
	}

	if (v_encoded == enc_ExpandedNodeId(v_dec)) {
	setverdict(pass);
	} else {
	setverdict(fail);
	}
	}

	function f_EncDec_MessageTypes(MessageTypes v_orig) {
	var MessageTypes v_dec;
	var octetstring v_encoded := enc_MessageTypes(v_orig);

	if (dec_MessageTypes(v_encoded, v_dec) == -1) {
	setverdict(fail, "Failed to decode message chunk!");
	return;
	}

	if (v_encoded == enc_MessageTypes(v_dec)) {
	setverdict(pass);
	} else {
	setverdict(fail);
	}
	}

	testcase tc_EncDecDec_ObjectAttributes() runs on MyComp {
	f_EncDecDec_ObjectAttributes();
	}

	testcase tc_EncDecDec_VariableAttributes() runs on MyComp {
	f_EncDecDec_VariableAttributes();
	}

	testcase tc_EncDecDec_MethodAttributes() runs on MyComp {
	f_EncDecDec_MethodAttributes();
	}

	testcase tc_EncDecDec_ObjectTypeAttributes() runs on MyComp {
	f_EncDecDec_ObjectTypeAttributes();
	}

	testcase tc_EncDecDec_VariableTypeAttributes() runs on MyComp {
	f_EncDecDec_VariableTypeAttributes();
	}

	testcase tc_EncDecDec_ReferenceTypeAttributes() runs on MyComp {
	f_EncDecDec_ReferenceTypeAttributes();
	}

	testcase tc_EncDecDec_DataTypeAttributes() runs on MyComp {
	f_EncDecDec_DataTypeAttributes();
	}

	testcase tc_EncDecDec_ViewAttributes() runs on MyComp {
	f_EncDecDec_ViewAttributes();
	}

	testcase tc_EncDecDec_DataValue() runs on MyComp {
	f_EncDecDec_DataValue();
	}

	testcase tc_EncDecDec_NodeIdUInt32() runs on MyComp {
	f_EncDec_NodeIdUInt32();
	}

	testcase tc_EncDecDec_NodeIdGuid() runs on MyComp {
	f_EncDec_NodeIdGuid();
	}

	testcase tc_EncDecDec_ExpandedNodeIdByteString() runs on MyComp {
	f_EncDec_ExpandedNodeIdByteString();
	}

	testcase tc_EncDecDec_HelloMessage() runs on MyComp {
	var MessageTypes v_orig := {
	HelloMessage := {
	messageType := HelloHeaderMsgType,
	chunkType := FinalChunk,
	messageSize := 0,
	version := 1,
	receiveBufferSize := 256,
	sendBufferSize := 256,
	maxMessageSize := 200,
	maxChunkCount := 2,
	endPointUrl := "EndPoint"
	}
	}

	v_orig.HelloMessage.messageSize := f_CalculateSize(v_orig);

	f_EncDec_MessageTypes(v_orig);
	}

	testcase tc_EncDecDec_AckMessage() runs on MyComp {
	var MessageTypes v_orig := {
	AckMessage := {
	messageType := HelloHeaderMsgType,
	chunkType := FinalChunk,
	messageSize := 0,
	version := 1,
	receiveBufferSize := 256,
	sendBufferSize := 256,
	maxMessageSize := 200,
	maxChunkCount := 2
	}
	}

	v_orig.AckMessage.messageSize := f_CalculateSize(v_orig);

	f_EncDec_MessageTypes(v_orig);
	}

	testcase tc_EncDecDec_ErrorMessage() runs on MyComp {
	var MessageTypes v_orig := {
	ErrorMessage := {
	messageType := HelloHeaderMsgType,
	chunkType := FinalChunk,
	messageSize := 0,
	errorCode := 1234,
	reason := "reason"
	}
	}

	v_orig.ErrorMessage.messageSize := f_CalculateSize(v_orig);

	f_EncDec_MessageTypes(v_orig);
	}

	testcase tc_EncDecDec_ReverseHelloMessage() runs on MyComp {
	var MessageTypes v_orig := {
	ReverseHelloMessage := {
	messageType := HelloHeaderMsgType,
	chunkType := FinalChunk,
	messageSize := 0,
	serverUri := "Server",
	endPointUrl := "url"
	}
	}

	v_orig.ReverseHelloMessage.messageSize := f_CalculateSize(v_orig);

	f_EncDec_MessageTypes(v_orig);
	}

	testcase tc_EncDec_OpenSecureChannelRequest() runs on MyComp {
	var MessageTypes v_orig := {
	OpenSecureChannelRequest := {
	messageType := OpenSecureChannelMsgType,
	chunkType := FinalChunk,
	messageSize := 0,

	securityChannelId := 1,
	securePolicyUri := {2, 3, 4},
	senderCertificate := {55, 6, 7},
	receiverCertificateThumbprint := {0, 1},
	sequenceHeader := {
	SequenceNumber := 1,
	RequestId := 0
	},

	encodingByte := 22,
	namespaceIndex := 0,
	nodeValue := OpenSecureChannelRequestNodeId,

	requestHeader := {
	authenticationToken := valueof(tr_NodeId_String("Id", omit)),
	timestamp := "2018.04.13",
	requestHandle := 2,
	returnDiagnostics := 1,
	auditEntryId := "tmp",
	timeoutHint := 0,
	additionalHeader := {
	typeId := valueof(tr_ExpandedNodeId_GUID("AS", tr_Namespace_1, "namespace")),
	Value := 1
	}
	},
	clientProtocolVersion := 1,
	requestType := ISSUE_0,
	securityMode := NONE_1,
	clientNonce := "client",
	requestedLifetime := 60
	}
	}

	v_orig.OpenSecureChannelRequest.messageSize := f_CalculateSize(v_orig);

	f_EncDec_MessageTypes(v_orig);
	}

	testcase tc_EncDec_GetEndpointsResponse() runs on MyComp {
	var MessageTypes v_orig := {
	GetEndpointsResponse := {
	messageType := ServicesMsgType,
	chunkType := FinalChunk,
	messageSize := 0,

	securityChannelId := 1,
	securityTokenId := 2,
	sequenceHeader := {
	SequenceNumber := 2,
	RequestId := 0
	},

	encodingByte := 22,
	namespaceIndex := 0,
	nodeValue := GetEndpointsResponseNodeId,

	responseHeader := {
	timestamp := "2018.04.13",
	requestHandle := 3,
	serviceResult := omit,
	serviceDiagnostics := {
	SymbolicId := 1,
	NamespaceUri := 0,
	Locale := 1,
	LocalizedText := 22,
	AdditionalInfo := "Hello",
	InnerStatusCode := {
	Code := 1,
	Symbol := "Error"
	},
	InnerDiagnosticInfo := omit
	},
	stringTable := {"Hello", "Bye"},
	additionalHeader := {
	typeId := valueof(tr_ExpandedNodeId_GUID("AS", tr_Namespace("namespace"), omit)),
	Value := 1
	}
	},
	Endpoints := {
	{
	endpointUrl := "URL",
	server := {
	applicationUri := "uri",
	productUri := "product",
	applicationName := {
	locale := "Locale",
	text := "Text"
	},
	applicationType := CLIENT_1,
	gatewayServerUri := "gatewayServerUri",
	discoveryProfileUri := "discoveryProfileUri",
	discoveryUrls := {"discoveryUrls", "discoveryUrls"}
	},
	serverCertificate := "001010",
	securityMode := NONE_1,
	securityPolicyUri := "discoveryUrls",
	userIdentityTokens := {
	{
	policyId := "Policy",
	tokenType := USERNAME_1,
	issuedTokenType := "ASD",
	issuerEndpointUrl := "URL",
	securityPolicyUri := "URI"
	}
	},
	transportProfileUri := "URI",
	securityLevel := 0
	}
	}
	}
	}

	v_orig.GetEndpointsResponse.messageSize := f_CalculateSize(v_orig);

	f_EncDec_MessageTypes(v_orig);
	}

	control {
	//Encode and decode structures with test encoders
	execute(tc_EncDecDec_ObjectAttributes());
	execute(tc_EncDecDec_VariableAttributes());
	execute(tc_EncDecDec_MethodAttributes());
	execute(tc_EncDecDec_ObjectTypeAttributes());
	execute(tc_EncDecDec_VariableTypeAttributes());
	execute(tc_EncDecDec_ReferenceTypeAttributes());
	execute(tc_EncDecDec_DataTypeAttributes());
	execute(tc_EncDecDec_ViewAttributes());
	execute(tc_EncDecDec_DataValue());
	execute(tc_EncDecDec_NodeIdUInt32());
	execute(tc_EncDecDec_NodeIdGuid());
	execute(tc_EncDecDec_ExpandedNodeIdByteString());

	//Encode and decode messages
	execute(tc_EncDecDec_HelloMessage());
	execute(tc_EncDecDec_AckMessage());
	execute(tc_EncDecDec_ErrorMessage());
	execute(tc_EncDecDec_ReverseHelloMessage());
	execute(tc_EncDec_OpenSecureChannelRequest());
	execute(tc_EncDec_GetEndpointsResponse());
	}
	} with { encode "JSON" }