diff --git a/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/src/Primitives/ScmKnownParameters.cs b/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/src/Primitives/ScmKnownParameters.cs index e07006acf43..ad1d9ddb372 100644 --- a/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/src/Primitives/ScmKnownParameters.cs +++ b/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/src/Primitives/ScmKnownParameters.cs @@ -2,6 +2,7 @@ // Licensed under the MIT License. using System; +using System.ClientModel; using System.ClientModel.Primitives; using System.Text.Json; using System.Threading; diff --git a/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/src/Providers/Samples/ClientSampleProvider.cs b/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/src/Providers/Samples/ClientSampleProvider.cs new file mode 100644 index 00000000000..10cb3cef74f --- /dev/null +++ b/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/src/Providers/Samples/ClientSampleProvider.cs @@ -0,0 +1,577 @@ +// Copyright (c) Microsoft Corporation. All rights reserved. +// Licensed under the MIT License. + +using System; +using System.ClientModel; +using System.Collections.Generic; +using System.IO; +using System.Linq; +using System.Reflection; +using System.Text.Json; +using System.Threading.Tasks; +using Microsoft.TypeSpec.Generator.Expressions; +using Microsoft.TypeSpec.Generator.Input; +using Microsoft.TypeSpec.Generator.Primitives; +using Microsoft.TypeSpec.Generator.Providers; +using Microsoft.TypeSpec.Generator.Samples; +using Microsoft.TypeSpec.Generator.Statements; +using static Microsoft.TypeSpec.Generator.Snippets.Snippet; + +namespace Microsoft.TypeSpec.Generator.ClientModel.Providers.Samples +{ + /// + /// Generates a Samples_{ClientName}.cs file containing compilable example methods + /// for each operation on a client. Each example method is annotated with [Test] and + /// [Ignore("Only validating compilation of examples")] so it compiles but doesn't + /// run in normal test suites. + /// + public class ClientSampleProvider : TypeProvider + { + private static readonly CSharpType _testAttributeType = CreateExternalCSharpType("TestAttribute", "NUnit.Framework"); + private static readonly CSharpType _ignoreAttributeType = CreateExternalCSharpType("IgnoreAttribute", "NUnit.Framework"); + + private static readonly AttributeStatement _testAttribute = new AttributeStatement(_testAttributeType); + private static readonly AttributeStatement _ignoreAttribute = new AttributeStatement( + _ignoreAttributeType, Literal("Only validating compilation of examples")); + + private readonly ClientProvider _client; + + public ClientSampleProvider(ClientProvider client) + { + _client = client; + } + + /// + /// Whether this provider has any sample methods to generate. + /// + public bool IsEmpty => Methods.Count == 0; + + protected override string BuildRelativeFilePath() + => Path.Combine("tests", "Generated", "Samples", $"{Name}.cs"); + + protected override string BuildName() => $"Samples_{_client.Name}"; + + protected override TypeSignatureModifiers BuildDeclarationModifiers() + => TypeSignatureModifiers.Public | TypeSignatureModifiers.Partial; + + protected override MethodProvider[] BuildMethods() + { + var methods = new List(); + + // Ensure client methods are built so MethodCache is populated + _ = _client.Methods; + + foreach (var serviceMethod in _client.InputClient.Methods) + { + ScmMethodProviderCollection methodCollection; + try + { + methodCollection = _client.GetMethodCollectionByOperation(serviceMethod.Operation); + } + catch + { + continue; + } + + foreach (var sample in BuildSamplesForOperation(_client, methodCollection, serviceMethod)) + { + methods.Add(BuildSampleMethod(sample, isAsync: false)); + methods.Add(BuildSampleMethod(sample, isAsync: true)); + } + } + + return [.. methods]; + } + + /// + /// Builds the list of instances for a single operation. + /// Override this method to customize which samples are generated. + /// + protected virtual IReadOnlyList BuildSamplesForOperation( + ClientProvider client, + ScmMethodProviderCollection methodCollection, + InputServiceMethod serviceMethod) + { + var protocolMethod = methodCollection.MethodProviders.FirstOrDefault(m => + m.Kind == ScmMethodKind.Protocol && + !m.Signature.Modifiers.HasFlag(MethodSignatureModifiers.Async)); + + if (protocolMethod == null || !OperationSample.ShouldGenerateSample(client, protocolMethod.Signature)) + { + return []; + } + + bool shouldGenerateConvenienceSamples = methodCollection.MethodProviders.Any(m => + m.Kind == ScmMethodKind.Convenience && + !m.Signature.Modifiers.HasFlag(MethodSignatureModifiers.Async) && + m.Signature.Modifiers.HasFlag(MethodSignatureModifiers.Public)); + + var examples = serviceMethod.Operation.Examples; + + // When no explicit examples are provided, synthesize mock examples so that + // every public operation still gets a compilable sample. + if (examples.Count == 0) + { + examples = ExampleMockValueBuilder.BuildOperationExamples(serviceMethod.Operation); + } + + bool shouldGenerateShortVersion = OperationSample.ShouldGenerateShortVersion(methodCollection); + + List samples = new(); + foreach (var example in examples) + { + if (!shouldGenerateShortVersion && example.Name == "ShortVersion") + { + continue; + } + + samples.Add(new OperationSample(client, methodCollection, serviceMethod, example, false, example.Name)); + + if (shouldGenerateConvenienceSamples) + { + samples.Add(new OperationSample(client, methodCollection, serviceMethod, example, true, example.Name)); + } + } + + return samples; + } + + // ------------------------------------------------------------------- + // Method building + // ------------------------------------------------------------------- + + private MethodProvider BuildSampleMethod(OperationSample sample, bool isAsync) + { + var methodName = GetMethodName(sample, isAsync); + var returnType = isAsync ? new CSharpType(typeof(Task)) : null; + var modifiers = MethodSignatureModifiers.Public; + if (isAsync) + modifiers |= MethodSignatureModifiers.Async; + + var signature = new MethodSignature( + Name: methodName, + Description: $"{sample.GetSampleInformation(isAsync)}", + Modifiers: modifiers, + ReturnType: returnType, + ReturnDescription: null, + Parameters: [], + Attributes: [_testAttribute, _ignoreAttribute]); + + var body = BuildSampleMethodBody(sample, isAsync); + + return new MethodProvider(signature, body, this); + } + + private MethodBodyStatement BuildSampleMethodBody(OperationSample sample, bool isAsync) + { + var clientVarDeclarations = new List(); + var clientStatement = BuildGetClientStatement(sample, clientVarDeclarations, out var clientVar); + + var operationVarDeclarations = new List(); + // Force enumeration so that operationVarDeclarations is populated + // before it is spread into the method body (same pattern as autorest's .ToArray()). + var operationStatements = BuildSampleOperationInvocation(sample, clientVar, operationVarDeclarations, isAsync).ToArray(); + + return new MethodBodyStatements( + [ + .. clientVarDeclarations, + clientStatement, + MethodBodyStatement.EmptyLine, + .. operationVarDeclarations, + .. operationStatements, + ]); + } + + // ------------------------------------------------------------------- + // Client construction + // ------------------------------------------------------------------- + + /// + /// Generates the client construction statement: + /// + /// Uri endpoint = new Uri("<endpoint>"); + /// FooClient client = new FooClient(endpoint, credential).GetSubClient(); + /// + /// + private MethodBodyStatement BuildGetClientStatement( + OperationSample sample, + List variableDeclarations, + out VariableExpression clientVar) + { + var chain = sample.ClientInvocationChain; + if (chain.Count == 0) + { + clientVar = new VariableExpression(_client.Type, "client"); + return Declare(clientVar, Null); + } + + // First element is a constructor + var first = chain[0]; + ValueExpression valueExpression; + if (first is ConstructorSignature ctor) + { + var ctorArgs = sample.GetValueExpressionsForParameters(ctor.Parameters, variableDeclarations); + valueExpression = New.Instance(ctor.Type, [.. ctorArgs]); + } + else + { + var methodArgs = sample.GetValueExpressionsForParameters(first.Parameters, variableDeclarations); + valueExpression = new InvokeMethodExpression(null, first.Name, [.. methodArgs]); + } + + // Chain remaining factory methods + for (int i = 1; i < chain.Count; i++) + { + var method = chain[i]; + var methodArgs = sample.GetValueExpressionsForParameters(method.Parameters, variableDeclarations); + valueExpression = valueExpression.Invoke(method.Name, [.. methodArgs]); + } + + clientVar = new VariableExpression(_client.Type, "client"); + return Declare(clientVar, valueExpression); + } + + // ------------------------------------------------------------------- + // Operation invocation + // ------------------------------------------------------------------- + + /// + /// Generates the operation invocation and response handling: + /// + /// Response response = client.DoSomething(param1, param2); + /// JsonElement result = JsonDocument.Parse(response.ContentStream).RootElement; + /// Console.WriteLine(result.GetProperty("name").ToString()); + /// + /// + private IEnumerable BuildSampleOperationInvocation( + OperationSample sample, + VariableExpression clientVar, + List variableDeclarations, + bool isAsync) + { + var methodSignature = sample.OperationMethodSignature; + var parameterExpressions = sample.GetValueExpressionsForParameters( + methodSignature.Parameters, variableDeclarations); + + // Build the invocation expression: client.MethodName(args) + // The resolved signature is always the sync variant; append "Async" when generating async samples + // so we call the correct async overload (which returns Task). + var methodName = isAsync ? methodSignature.Name + "Async" : methodSignature.Name; + + // For pageable operations, don't wrap in await — ForEachStatement handles "await foreach". + // Pageable methods return CollectionResult/AsyncCollectionResult directly (not Task). + var wrapInAwait = isAsync && !sample.IsPageable; + var invocation = clientVar.Invoke( + methodName, + [.. parameterExpressions], + wrapInAwait); + + var returnType = methodSignature.ReturnType; + + // Normal (non-pageable, non-LRO) operation + if (!sample.IsPageable && !sample.IsLongRunning) + { + if (returnType == null) + { + yield return invocation.Terminate(); + yield break; + } + + var responseVar = new VariableExpression(returnType, "response"); + yield return Declare(responseVar, invocation); + yield return MethodBodyStatement.EmptyLine; + + foreach (var stmt in BuildResponseStatements(sample, responseVar)) + { + yield return stmt; + } + yield break; + } + + // Pageable operation + if (sample.IsPageable && !sample.IsLongRunning) + { + yield return BuildPageableStatements(sample, invocation, isAsync); + yield break; + } + + // Long-running operation (with or without paging) + if (sample.IsLongRunning) + { + if (returnType == null) + { + yield return invocation.Terminate(); + yield break; + } + + var operationVar = new VariableExpression(returnType, "operation"); + yield return Declare(operationVar, invocation); + yield return MethodBodyStatement.EmptyLine; + + // Access the result value + var valueExpr = operationVar.Property("Value"); + + if (sample.IsPageable) + { + yield return BuildPageableStatements(sample, valueExpr, isAsync); + } + else + { + var resultVar = new VariableExpression(new CSharpType(typeof(BinaryData)), "responseData"); + yield return Declare(resultVar, valueExpr); + yield return MethodBodyStatement.EmptyLine; + + foreach (var stmt in BuildResponseStatements(sample, resultVar)) + { + yield return stmt; + } + } + yield break; + } + } + + // ------------------------------------------------------------------- + // Response handling + // ------------------------------------------------------------------- + + /// + /// Builds response handling statements for the generated sample method. + /// For protocol methods: parses JSON and prints property values via Console.WriteLine. + /// For convenience methods: no response handling is generated. + /// + private IEnumerable BuildResponseStatements( + OperationSample sample, + VariableExpression responseVar) + { + // Convenience methods skip response handling + if (sample.IsConvenienceSample) + yield break; + + // No response body — nothing to parse + if (!sample.HasResponseBody) + yield break; + + // Stream responses + if (sample.IsResponseStream) + { + foreach (var stmt in BuildStreamResponseStatements(responseVar)) + yield return stmt; + yield break; + } + + // Determine how to obtain a parseable stream based on the response variable's type. + // This mirrors autorest's BuildNormalResponse dispatch: + // BinaryData (from LRO operation.Value) → .ToStream() + // ClientResult / ClientResult → .GetRawResponse().ContentStream + ValueExpression streamExpr; + var responseType = responseVar.Type; + if (responseType.IsFrameworkType && responseType.FrameworkType == typeof(BinaryData)) + { + streamExpr = responseVar.Invoke(nameof(BinaryData.ToStream), []); + } + else + { + streamExpr = responseVar.Invoke("GetRawResponse", []).Property("ContentStream"); + } + + var parseExpr = Static(typeof(JsonDocument)).Invoke(nameof(JsonDocument.Parse), streamExpr) + .Property(nameof(JsonDocument.RootElement)); + + var resultVar = new VariableExpression(new CSharpType(typeof(JsonElement)), "result"); + yield return Declare(resultVar, parseExpr); + + // Build response property parsing (recursive) + if (sample.ResultType != null) + { + foreach (var stmt in BuildResponseParseStatements( + sample.IsAllParametersUsed, sample.ResultType, resultVar, new HashSet())) + { + yield return stmt; + } + } + } + + /// + /// Recursively walks the response type's properties and generates + /// Console.WriteLine(result.GetProperty("name").ToString()); statements. + /// + private IEnumerable BuildResponseParseStatements( + bool useAllProperties, + InputType type, + ValueExpression invocation, + HashSet visitedTypes) + { + switch (type) + { + case InputArrayType arrayType: + // Array → access [0] then recurse into element type + var indexedExpr = new IndexerExpression(invocation, Literal(0)); + foreach (var stmt in BuildResponseParseStatements(useAllProperties, arrayType.ValueType, indexedExpr, visitedTypes)) + { + yield return stmt; + } + yield break; + + case InputModelType modelType: + // Prevent infinite recursion + if (!visitedTypes.Add(modelType)) + yield break; + + foreach (var stmt in BuildResponseParseStatementsForModel( + useAllProperties, modelType, invocation, visitedTypes)) + { + yield return stmt; + } + + visitedTypes.Remove(modelType); + yield break; + + default: + // Primitive → Console.WriteLine(expr.ToString()) + yield return ConsoleWriteLine(invocation.Invoke("ToString", [])); + yield break; + } + } + + /// + /// Walks a model type's properties and generates GetProperty() chains with Console.WriteLine(). + /// + private IEnumerable BuildResponseParseStatementsForModel( + bool useAllProperties, + InputModelType modelType, + ValueExpression invocation, + HashSet visitedTypes) + { + foreach (var model in GetSelfAndBaseModels(modelType)) + { + foreach (var property in model.Properties) + { + // Skip optional properties unless using all + if (!useAllProperties && !property.IsRequired) + continue; + + var propertyExpr = invocation.Invoke("GetProperty", Literal(property.SerializedName ?? property.Name)); + + foreach (var stmt in BuildResponseParseStatements( + useAllProperties, property.Type, propertyExpr, visitedTypes)) + { + yield return stmt; + } + } + } + } + + /// + /// Generates statements for stream responses: + /// + /// if (response.GetRawResponse().ContentStream != null) { ... } + /// + /// + private static IEnumerable BuildStreamResponseStatements(VariableExpression responseVar) + { + var contentStreamExpr = responseVar.Invoke("GetRawResponse", []).Property("ContentStream"); + var ifStatement = new IfStatement(contentStreamExpr.NotEqual(Null)) + { + ConsoleWriteLine(Literal("Response has content stream")) + }; + yield return ifStatement; + } + + /// + /// Generates pageable iteration. + /// Protocol: foreach (ClientResult page in result.GetRawPages()) { ... } + /// Convenience: foreach (Thing item in result) { Console.WriteLine(item.ToString()); } + /// + private MethodBodyStatement BuildPageableStatements( + OperationSample sample, + ValueExpression enumerableExpr, + bool isAsync) + { + if (sample.IsConvenienceSample) + { + // Convenience: iterate typed items directly. + // CollectionResult / AsyncCollectionResult implement IEnumerable / IAsyncEnumerable. + var resultType = sample.ResultType; + CSharpType itemType = new CSharpType(typeof(BinaryData)); + if (resultType != null) + { + itemType = CodeModelGenerator.Instance.TypeFactory.CreateCSharpType(resultType) ?? itemType; + } + var forEach = new ForEachStatement(itemType, "item", enumerableExpr, isAsync, out var item); + forEach.Add(ConsoleWriteLine(item.Invoke("ToString", []))); + return forEach; + } + else + { + // Protocol: CollectionResult / AsyncCollectionResult do not implement IEnumerable directly. + // Iterate pages via GetRawPages() / GetRawPagesAsync(). + var pagesMethod = isAsync ? "GetRawPagesAsync" : "GetRawPages"; + var pagesExpr = enumerableExpr.Invoke(pagesMethod, []); + var forEach = new ForEachStatement(new CSharpType(typeof(ClientResult)), "page", pagesExpr, isAsync, out var page); + forEach.Add(ConsoleWriteLine(page.Invoke("ToString", []))); + return forEach; + } + } + + // ------------------------------------------------------------------- + // Method naming + // ------------------------------------------------------------------- + + /// + /// Generates the method name following the pattern: + /// Example_{ResourceName}_{OperationName}_{ExampleKey}[_Convenience][_Async] + /// + private static string GetMethodName(OperationSample sample, bool isAsync) + { + var name = $"Example_{sample.ResourceName}_{sample.InputOperationName}_{sample.ExampleKey}"; + + if (sample.IsConvenienceSample) + name += "_Convenience"; + + if (isAsync) + name += "_Async"; + + return name; + } + + // ------------------------------------------------------------------- + // Helpers + // ------------------------------------------------------------------- + + /// + /// Generates a Console.WriteLine(expression) statement without fully qualifying + /// the Console type. The standard Snippet.InvokeConsoleWriteLine uses + /// Static(typeof(Console)) which the CodeWriter renders as global::System.Console. + /// Since the generated file already has using System;, this helper emits the shorter form. + /// + private static MethodBodyStatement ConsoleWriteLine(ValueExpression expression) + => new InvokeMethodExpression(null, "Console.WriteLine", [expression]).Terminate(); + + private static IEnumerable GetSelfAndBaseModels(InputModelType model) + { + var current = model; + while (current != null) + { + yield return current; + current = current.BaseModel; + } + } + + /// + /// Creates a for an external type (e.g., NUnit attributes) + /// that is not referenced by this assembly. Uses the internal string-based constructor + /// via reflection. + /// + private static CSharpType CreateExternalCSharpType(string name, string ns) + { + var ctor = typeof(CSharpType).GetConstructor( + BindingFlags.NonPublic | BindingFlags.Instance, + null, + [typeof(string), typeof(string), typeof(bool), typeof(bool), + typeof(CSharpType), typeof(IReadOnlyList), + typeof(bool), typeof(bool), typeof(CSharpType), typeof(Type)], + null)!; + return (CSharpType)ctor.Invoke([name, ns, false, false, null, Array.Empty(), true, false, null, null]); + } + } +} diff --git a/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/src/Providers/Samples/ExampleParameterValue.cs b/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/src/Providers/Samples/ExampleParameterValue.cs new file mode 100644 index 00000000000..5ff6aa62201 --- /dev/null +++ b/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/src/Providers/Samples/ExampleParameterValue.cs @@ -0,0 +1,55 @@ +// Copyright (c) Microsoft Corporation. All rights reserved. +// Licensed under the MIT License. + +using Microsoft.TypeSpec.Generator.Expressions; +using Microsoft.TypeSpec.Generator.Input; +using Microsoft.TypeSpec.Generator.Primitives; + +namespace Microsoft.TypeSpec.Generator.ClientModel.Providers.Samples +{ + /// + /// Represents a parameter value in a sample. Supports two modes: + /// - : raw example data that will be converted to a C# expression later + /// - : a pre-built C# expression (used for known parameters like credentials, endpoints) + /// + public class ExampleParameterValue + { + public ExampleParameterValue(string name, CSharpType type, InputExampleValue value) + { + Name = name; + Type = type; + Value = value; + } + + public ExampleParameterValue(string name, CSharpType type, ValueExpression expression) + { + Name = name; + Type = type; + Expression = expression; + } + + /// + /// The parameter name. + /// + public string Name { get; } + + /// + /// The C# type of the parameter. + /// + public CSharpType Type { get; } + + /// + /// Raw example data from the spec or mock builder. Will be converted to a + /// via . + /// Mutually exclusive with . + /// + public InputExampleValue? Value { get; } + + /// + /// A pre-built C# expression. Used for known parameters (credentials, endpoints) + /// where the expression is fixed regardless of example data. + /// Mutually exclusive with . + /// + public ValueExpression? Expression { get; } + } +} diff --git a/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/src/Providers/Samples/ExampleValueExpressionBuilder.cs b/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/src/Providers/Samples/ExampleValueExpressionBuilder.cs new file mode 100644 index 00000000000..0c7512f047a --- /dev/null +++ b/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/src/Providers/Samples/ExampleValueExpressionBuilder.cs @@ -0,0 +1,412 @@ +// Copyright (c) Microsoft Corporation. All rights reserved. +// Licensed under the MIT License. + +using System; +using System.ClientModel; +using System.Collections.Generic; +using System.IO; +using System.Linq; +using System.Text; +using System.Xml; +using Microsoft.TypeSpec.Generator.Expressions; +using Microsoft.TypeSpec.Generator.Input; +using Microsoft.TypeSpec.Generator.Input.Extensions; +using Microsoft.TypeSpec.Generator.Primitives; +using Microsoft.TypeSpec.Generator.Providers; +using static Microsoft.TypeSpec.Generator.Snippets.Snippet; + +namespace Microsoft.TypeSpec.Generator.ClientModel.Providers.Samples +{ + /// + /// Converts + into (C# AST nodes). + /// This is the bridge between raw mock/spec example data and generated C# code. + /// + public static class ExampleValueExpressionBuilder + { + /// + /// Converts an to a C# expression. + /// If the parameter has a pre-built expression, returns it directly. + /// Otherwise, converts the raw using type information. + /// + public static ValueExpression GetExpression(ExampleParameterValue parameterValue, SerializationFormat format = SerializationFormat.Default) + { + if (parameterValue.Expression != null) + return parameterValue.Expression; + + if (parameterValue.Value != null) + return GetExpression(parameterValue.Type, parameterValue.Value, format); + + return Default; + } + + /// + /// Converts an to a C# expression based on the target . + /// + public static ValueExpression GetExpression(CSharpType type, InputExampleValue exampleValue, SerializationFormat format = SerializationFormat.Default) + { + if (type.IsList) + return GetExpressionForList(type, exampleValue); + if (type.IsDictionary) + return GetExpressionForDictionary(type, exampleValue); + if (type.IsEnum) + return GetExpressionForEnum(type, exampleValue); + if (type is { IsFrameworkType: true }) + return GetExpressionForFrameworkType(type.FrameworkType, exampleValue, format); + + // For model types, fall back to default + return GetExpressionForModel(type, exampleValue); + } + + private static ValueExpression GetExpressionForFrameworkType(Type frameworkType, InputExampleValue exampleValue, SerializationFormat format = SerializationFormat.Default) + { + var rawValue = GetRawValue(exampleValue); + + // String + if (frameworkType == typeof(string)) + { + return rawValue is string s ? Literal(s) : Null; + } + + // Boolean + if (frameworkType == typeof(bool)) + { + return rawValue is bool b ? Literal(b) : Default; + } + + // Integer types + if (frameworkType == typeof(int)) + { + return rawValue != null ? Literal(Convert.ToInt32(rawValue)) : Default; + } + if (frameworkType == typeof(long)) + { + return rawValue != null ? Literal(Convert.ToInt64(rawValue)) : Default; + } + if (frameworkType == typeof(short)) + { + return rawValue != null ? new CastExpression(Literal(Convert.ToInt16(rawValue)), frameworkType) : Default; + } + if (frameworkType == typeof(sbyte)) + { + return rawValue != null ? new CastExpression(Literal(Convert.ToSByte(rawValue)), frameworkType) : Default; + } + if (frameworkType == typeof(byte)) + { + return rawValue != null ? new CastExpression(Literal(Convert.ToByte(rawValue)), frameworkType) : Default; + } + if (frameworkType == typeof(ushort)) + { + return rawValue != null ? new CastExpression(Literal(Convert.ToUInt16(rawValue)), frameworkType) : Default; + } + if (frameworkType == typeof(uint)) + { + return rawValue != null ? new CastExpression(Literal(Convert.ToUInt32(rawValue)), frameworkType) : Default; + } + if (frameworkType == typeof(ulong)) + { + return rawValue != null ? new CastExpression(Literal(Convert.ToUInt64(rawValue)), frameworkType) : Default; + } + + // Float types + if (frameworkType == typeof(float)) + { + return rawValue != null ? Literal(Convert.ToSingle(rawValue)) : Default; + } + if (frameworkType == typeof(double)) + { + return rawValue != null ? Literal(Convert.ToDouble(rawValue)) : Default; + } + if (frameworkType == typeof(decimal)) + { + return rawValue != null ? Literal(Convert.ToDecimal(rawValue)) : Default; + } + + // Guid + if (frameworkType == typeof(Guid)) + { + if (rawValue is string s) + return Static(typeof(Guid)).Invoke(nameof(Guid.Parse), Literal(s)); + return Default; + } + + // Uri + if (frameworkType == typeof(Uri)) + { + if (rawValue is string s) + return New.Instance(typeof(Uri), Literal(s)); + return Null; + } + + // DateTimeOffset + if (frameworkType == typeof(DateTimeOffset)) + { + if (format == SerializationFormat.DateTime_Unix) + { + var unixValue = rawValue is string us ? Convert.ToInt64(us) : rawValue is int or long ? Convert.ToInt64(rawValue) : 0L; + return Static(typeof(DateTimeOffset)).Invoke(nameof(DateTimeOffset.FromUnixTimeSeconds), Literal(unixValue)); + } + if (rawValue is string s) + return Static(typeof(DateTimeOffset)).Invoke(nameof(DateTimeOffset.Parse), Literal(s)); + if (rawValue is int or long) + return Static(typeof(DateTimeOffset)).Invoke(nameof(DateTimeOffset.FromUnixTimeSeconds), Literal(Convert.ToInt64(rawValue))); + return Default; + } + + // TimeSpan + if (frameworkType == typeof(TimeSpan)) + { + if (format is SerializationFormat.Duration_Seconds or SerializationFormat.Duration_Seconds_Float or SerializationFormat.Duration_Milliseconds) + { + if (rawValue is string ds) + return Static(typeof(TimeSpan)).Invoke(nameof(TimeSpan.FromSeconds), Literal(Convert.ToDouble(ds))); + if (rawValue is int or float or double) + return Static(typeof(TimeSpan)).Invoke(nameof(TimeSpan.FromSeconds), Literal(Convert.ToDouble(rawValue))); + } + if (rawValue is string s) + return Static(typeof(XmlConvert)).Invoke(nameof(XmlConvert.ToTimeSpan), Literal(s)); + if (rawValue is int or float or double) + return Static(typeof(TimeSpan)).Invoke(nameof(TimeSpan.FromSeconds), Literal(Convert.ToDouble(rawValue))); + return Default; + } + + // BinaryContent — BinaryContent.Create(BinaryData.FromObjectAsJson(new { ... })) + if (frameworkType == typeof(BinaryContent)) + { + var binaryDataExpr = GetExpressionForBinaryData(exampleValue); + return Static(typeof(BinaryContent)).Invoke(nameof(BinaryContent.Create), binaryDataExpr); + } + + // BinaryData + if (frameworkType == typeof(BinaryData)) + { + if (rawValue == null && exampleValue is not InputExampleValue) + return Null; + return GetExpressionForBinaryData(exampleValue); + } + + // byte[] + if (frameworkType == typeof(byte[])) + { + if (rawValue is string s) + return Static(typeof(Encoding)).Property(nameof(Encoding.UTF8)) + .Invoke(nameof(Encoding.GetBytes), Literal(s)); + return Null; + } + + // Stream + if (frameworkType == typeof(Stream)) + { + if (exampleValue is InputExampleStreamValue streamValue) + return Static(typeof(File)).Invoke(nameof(File.OpenRead), Literal(streamValue.Filename)); + return Null; + } + + // Fallback + return frameworkType.IsValueType ? Default : Null; + } + + private static ValueExpression GetExpressionForList(CSharpType listType, InputExampleValue exampleValue) + { + var elementType = listType.ElementType; + var items = new List(); + + if (exampleValue is InputExampleListValue listValue) + { + foreach (var itemValue in listValue.Values) + { + items.Add(GetExpression(elementType, itemValue)); + } + } + + return New.Array(elementType, items.ToArray()); + } + + private static ValueExpression GetExpressionForDictionary(CSharpType dictionaryType, InputExampleValue exampleValue) + { + var keyType = dictionaryType.Arguments[0]; + var valueType = dictionaryType.Arguments[1]; + var entries = new Dictionary(); + + if (exampleValue is InputExampleObjectValue objectValue) + { + foreach (var (key, value) in objectValue.Values) + { + var keyExpr = GetExpression(keyType, InputExampleValue.Value(new InputPrimitiveType(InputPrimitiveTypeKind.String, "string", "TypeSpec.string"), key)); + var valueExpr = GetExpression(valueType, value); + entries[keyExpr] = valueExpr; + } + } + + return New.Dictionary(keyType, valueType, entries); + } + + private static ValueExpression GetExpressionForEnum(CSharpType enumType, InputExampleValue exampleValue) + { + var rawValue = GetRawValue(exampleValue); + if (rawValue == null) + return Default; + + // Match the wire value to the enum member's logical name, then convert to a valid C# identifier. + if (exampleValue.Type is InputEnumType inputEnumType) + { + var rawString = rawValue.ToString()!; + foreach (var enumValue in inputEnumType.Values) + { + if (string.Equals(enumValue.Value?.ToString(), rawString, StringComparison.Ordinal)) + { + return new MemberExpression(Static(enumType), enumValue.Name.ToIdentifierName()); + } + } + + // No matching member found — extensible enums accept unknown values via constructor, + // fixed enums fall back to default. + if (inputEnumType.IsExtensible) + { + var underlyingType = CodeModelGenerator.Instance.TypeFactory.CreateCSharpType(inputEnumType.ValueType); + if (underlyingType != null) + { + var literalValue = GetExpressionForFrameworkType(underlyingType.FrameworkType, exampleValue); + return New.Instance(enumType, literalValue); + } + } + } + + return Default; + } + + private static ValueExpression GetExpressionForModel(CSharpType type, InputExampleValue exampleValue) + { + if (type.IsValueType) + return Default; + + // Try to resolve the model's TypeProvider to get constructor parameters + if (exampleValue is InputExampleObjectValue objectValue && + CodeModelGenerator.Instance.TypeFactory.CSharpTypeMap.TryGetValue(type, out var typeProvider) && + typeProvider is ModelProvider modelProvider) + { + // Find the public constructor with the most parameters + ConstructorProvider? bestCtor = null; + foreach (var ctor in modelProvider.Constructors) + { + if (ctor.Signature.Modifiers.HasFlag(MethodSignatureModifiers.Public)) + { + if (bestCtor == null || ctor.Signature.Parameters.Count > bestCtor.Signature.Parameters.Count) + bestCtor = ctor; + } + } + + if (bestCtor != null && bestCtor.Signature.Parameters.Count > 0) + { + var arguments = new List(); + foreach (var param in bestCtor.Signature.Parameters) + { + InputExampleValue? matchedValue = null; + + // Try matching by parameter name + objectValue.Values.TryGetValue(param.Name, out matchedValue); + + // Try matching by wire serialized name + if (matchedValue == null && param.Property?.WireInfo?.SerializedName != null) + objectValue.Values.TryGetValue(param.Property.WireInfo.SerializedName, out matchedValue); + + // Try matching by property name + if (matchedValue == null && param.Property != null) + objectValue.Values.TryGetValue(param.Property.Name, out matchedValue); + + if (matchedValue != null) + { + arguments.Add(GetExpression(param.Type, matchedValue)); + } + else if (param.DefaultValue != null) + { + arguments.Add(param.DefaultValue); + } + else + { + arguments.Add(param.Type.IsValueType ? Default : Null); + } + } + + return New.Instance(type, [.. arguments]); + } + } + + return New.Instance(type); + } + + private static ValueExpression GetExpressionForBinaryData(InputExampleValue exampleValue) + { + // Build an anonymous object from the example value and wrap in BinaryData.FromObjectAsJson + var anonymousObj = GetExpressionForAnonymousObject(exampleValue); + return Static(typeof(BinaryData)).Invoke(nameof(BinaryData.FromObjectAsJson), anonymousObj); + } + + /// + /// Converts an example value to an anonymous object expression for use in + /// BinaryData.FromObjectAsJson() or BinaryContent.Create(). + /// + internal static ValueExpression GetExpressionForAnonymousObject(InputExampleValue exampleValue) + { + if (exampleValue is InputExampleObjectValue objectValue) + { + var properties = new Dictionary(); + foreach (var (key, value) in objectValue.Values) + { + var rawVal = GetRawValue(value); + // Skip null properties in anonymous objects (causes compilation errors) + if (rawVal == null && value is InputExampleRawValue) + continue; + + // Sanitize property names that are not valid C# identifiers (e.g., "xml-id" → "xmlId") + var safeKey = key.ToIdentifierName(useCamelCase: true); + var valueExpr = GetExpressionForAnonymousObject(value); + properties[Identifier(safeKey)] = valueExpr; + } + return properties.Count > 0 ? New.Anonymous(properties) : New.Instance(typeof(object)); + } + + if (exampleValue is InputExampleListValue listValue) + { + var items = new List(); + foreach (var item in listValue.Values) + { + items.Add(GetExpressionForAnonymousObject(item)); + } + return New.Array(new CSharpType(typeof(object)), items.ToArray()); + } + + if (exampleValue is InputExampleStreamValue streamValue) + { + return Static(typeof(File)).Invoke(nameof(File.OpenRead), Literal(streamValue.Filename)); + } + + // Raw value — convert to literal + var raw = GetRawValue(exampleValue); + if (raw == null) + return Null; + + return raw switch + { + string s => Literal(s), + bool b => Literal(b), + int i => Literal(i), + long l => Literal(l), + float f => Literal(f), + double d => Literal(d), + decimal m => Literal(m), + _ => Literal(raw.ToString()!) + }; + } + + /// + /// Extracts the raw value from an if it's a raw (primitive) value. + /// Returns null for non-raw values (lists, objects, streams). + /// + private static object? GetRawValue(InputExampleValue exampleValue) + { + if (exampleValue is InputExampleRawValue rawValue) + return rawValue.RawValue; + return null; + } + } +} diff --git a/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/src/Providers/Samples/OperationSample.cs b/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/src/Providers/Samples/OperationSample.cs new file mode 100644 index 00000000000..d318a6527f2 --- /dev/null +++ b/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/src/Providers/Samples/OperationSample.cs @@ -0,0 +1,762 @@ +// Copyright (c) Microsoft Corporation. All rights reserved. +// Licensed under the MIT License. + +using System; +using System.Collections.Generic; +using System.Diagnostics; +using System.Linq; +using System.Threading; +using Microsoft.TypeSpec.Generator.ClientModel.Primitives; +using Microsoft.TypeSpec.Generator.Expressions; +using Microsoft.TypeSpec.Generator.Input; +using Microsoft.TypeSpec.Generator.Primitives; +using Microsoft.TypeSpec.Generator.Providers; +using Microsoft.TypeSpec.Generator.Statements; +using static Microsoft.TypeSpec.Generator.Snippets.Snippet; + +namespace Microsoft.TypeSpec.Generator.ClientModel.Providers.Samples +{ + /// + /// Represents a single sample for an operation — the bridge between an + /// and the generated C# sample method. + /// Resolves client construction chains, parameter value mappings, and method invocation details. + /// Modeled after the autorest DpgOperationSample pattern. + /// + [DebuggerDisplay("{GetDebuggerDisplay(),nq}")] + public class OperationSample + { + private readonly ClientProvider _client; + private readonly ScmMethodProviderCollection _methodCollection; + private readonly InputServiceMethod _serviceMethod; + private readonly InputOperationExample _example; + private readonly MethodSignature _operationMethodSignature; + + private IReadOnlyList? _clientInvocationChain; + private Dictionary? _parameterValueMapping; + private InputType? _resultType; + + public OperationSample( + ClientProvider client, + ScmMethodProviderCollection methodCollection, + InputServiceMethod serviceMethod, + InputOperationExample example, + bool isConvenienceSample, + string exampleKey) + { + _client = client; + _methodCollection = methodCollection; + _serviceMethod = serviceMethod; + _example = example; + IsConvenienceSample = isConvenienceSample; + ExampleKey = exampleKey; + IsAllParametersUsed = exampleKey == "AllParameters"; + _operationMethodSignature = ResolveOperationSignature(); + } + + // ------------------------------------------------------------------- + // Core identity + // ------------------------------------------------------------------- + + /// + /// The example key, e.g. "ShortVersion" or "AllParameters". + /// + public string ExampleKey { get; } + + /// + /// Whether this is a convenience method sample (true) or protocol method sample (false). + /// + public bool IsConvenienceSample { get; } + + /// + /// Whether this sample uses all parameters (including optional). + /// + public bool IsAllParametersUsed { get; } + + // ------------------------------------------------------------------- + // Method info + // ------------------------------------------------------------------- + + /// + /// The input operation name. + /// + public string InputOperationName => _serviceMethod.Operation.Name; + + /// + /// The resource name from the operation, or the client name as fallback. + /// Used for method naming. + /// + public string? ResourceName => _serviceMethod.Operation.ResourceName ?? _client.InputClient.Name; + + /// + /// Whether the operation uses paging. + /// + public bool IsPageable => _serviceMethod is InputPagingServiceMethod; + + /// + /// Whether the operation is long-running. + /// + public bool IsLongRunning => _serviceMethod is InputLongRunningServiceMethod; + + /// + /// The method signature for the operation being sampled (protocol or convenience). + /// + public MethodSignature OperationMethodSignature => _operationMethodSignature; + + /// + /// Whether there is a response body on the operation. + /// + public bool HasResponseBody => _serviceMethod.Response?.Type != null; + + /// + /// Whether the response is a stream. + /// + public bool IsResponseStream => + _serviceMethod.Response?.Type is InputPrimitiveType { Kind: InputPrimitiveTypeKind.Stream }; + + /// + /// The effective result type of the operation. + /// For paging, this is the item type; for all others this is the response type. + /// + public InputType? ResultType => _resultType ??= GetEffectiveResponseType(); + + private MethodSignature ResolveOperationSignature() + { + var kind = IsConvenienceSample ? ScmMethodKind.Convenience : ScmMethodKind.Protocol; + var method = _methodCollection.MethodProviders + .FirstOrDefault(m => m.Kind == kind && !m.Signature.Modifiers.HasFlag(MethodSignatureModifiers.Async)); + return method?.Signature ?? _methodCollection.MethodProviders.First().Signature; + } + + // ------------------------------------------------------------------- + // Client invocation chain + // ------------------------------------------------------------------- + + /// + /// Ordered list of method signatures to invoke to construct the client: + /// [root ctor, .GetSubClient(), .GetLeafClient()]. + /// + public IReadOnlyList ClientInvocationChain => + _clientInvocationChain ??= BuildClientInvocationChain(); + + /// + /// Walks from the current client up to the root, collecting factory methods, + /// then pushes the root constructor. Returns the chain in top-down order. + /// + private IReadOnlyList BuildClientInvocationChain() + { + var callChain = new Stack(); + + // Walk from the current client up to root, collecting factory methods. + // For each client that has a parent, find the factory method on the parent + // that returns it, and push that onto the chain. + var currentInputClient = _client.InputClient; + while (currentInputClient.Parent != null) + { + var parentProvider = ResolveClientProvider(currentInputClient.Parent); + if (parentProvider != null) + { + var factoryMethod = FindSubClientFactoryMethod(parentProvider, currentInputClient.Name); + if (factoryMethod != null) + { + callChain.Push(factoryMethod); + } + } + currentInputClient = currentInputClient.Parent; + } + + // At the root, push the primary public constructor + var rootProvider = ResolveClientProvider(currentInputClient); + if (rootProvider != null) + { + var ctor = GetPrimaryPublicConstructor(rootProvider); + if (ctor != null) + { + callChain.Push(ctor); + } + } + + return callChain.ToArray(); + } + + private static ClientProvider? ResolveClientProvider(InputClient inputClient) + { + return ScmCodeModelGenerator.Instance.TypeFactory.CreateClient(inputClient); + } + + private static MethodSignature? FindSubClientFactoryMethod(ClientProvider parentProvider, string subClientName) + { + // Match the naming convention used by ClientProvider: + // If name ends with "Client" → "Get{name}", otherwise → "Get{name}Client" + var expectedMethodName = subClientName.EndsWith("Client", StringComparison.OrdinalIgnoreCase) + ? $"Get{subClientName}" + : $"Get{subClientName}Client"; + + foreach (var method in parentProvider.Methods) + { + if (method.Signature.Name.Equals(expectedMethodName, StringComparison.OrdinalIgnoreCase) && + !method.Signature.Modifiers.HasFlag(MethodSignatureModifiers.Async)) + { + return method.Signature; + } + } + return null; + } + + private static ConstructorSignature? GetPrimaryPublicConstructor(ClientProvider clientProvider) + { + ConstructorSignature? best = null; + foreach (var ctor in clientProvider.Constructors) + { + if (ctor.Signature.Modifiers.HasFlag(MethodSignatureModifiers.Public)) + { + if (best == null || ctor.Signature.Parameters.Count > best.Parameters.Count) + { + best = ctor.Signature; + } + } + } + return best; + } + + // ------------------------------------------------------------------- + // Parameter value mapping + // ------------------------------------------------------------------- + + /// + /// Maps parameter names to their example values (either pre-built expressions or raw data). + /// + public IReadOnlyDictionary ParameterValueMapping => + _parameterValueMapping ??= EnsureParameterValueMapping(); + + private Dictionary EnsureParameterValueMapping() + { + var result = new Dictionary(); + var parameters = GetAllParameters(); + var parameterExamples = GetAllParameterExamples(); + + foreach (var parameter in parameters) + { + if (result.ContainsKey(parameter.Name)) + continue; + + if (TryProcessKnownParameter(result, parameter)) + continue; + + // Find the corresponding example value + var exampleValue = FindExampleValueByName(parameterExamples, parameter.Name); + + if (exampleValue == null && parameter.WireInfo?.SerializedName != null) + { + exampleValue = FindExampleValueByName(parameterExamples, parameter.WireInfo.SerializedName); + } + + if (exampleValue != null) + { + result.Add(parameter.Name, new ExampleParameterValue(parameter.Name, parameter.Type, exampleValue)); + } + else if (parameter.DefaultValue == null) + { + // Required parameter with no example — use default + var expression = DefaultOf(parameter.Type); + result.Add(parameter.Name, new ExampleParameterValue(parameter.Name, parameter.Type, expression)); + } + // Optional parameters with no value are intentionally omitted + } + + return result; + } + + /// + /// Known parameters that receive special handling (endpoint, credentials, cancellation, etc). + /// + private bool TryProcessKnownParameter(Dictionary result, ParameterProvider parameter) + { + var type = parameter.Type; + + // WaitUntil — prefer Completed to make long-running samples deterministic. + if (type.Name == "WaitUntil") + { + result[parameter.Name] = new ExampleParameterValue( + parameter.Name, + type, + Static(type).Property("Completed")); + return true; + } + + // CancellationToken — skip entirely (we don't set it in samples) + if (parameter.Equals(ScmKnownParameters.CancellationToken)) + { + return true; + } + + // RequestOptions (required) — pass null explicitly to avoid ambiguity, similar + // to old RequestContextRequired handling in AutoRest. + if ((parameter.Equals(ScmKnownParameters.RequestOptions) || parameter.Equals(ScmKnownParameters.OptionalRequestOptions)) && + parameter.DefaultValue == null) + { + result[parameter.Name] = new ExampleParameterValue( + parameter.Name, + type, + Null.CastTo(type)); + return true; + } + + if (type.Equals(typeof(Uri)) && parameter.Name.Equals("endpoint", StringComparison.OrdinalIgnoreCase)) + { + var endpointExpr = GetEndpointValue(parameter.Name); + result[parameter.Name] = new ExampleParameterValue(parameter.Name, type, endpointExpr); + return true; + } + + // Request content (BinaryContent) — handled specially via body parameter lookup + if (parameter.IsContentParameter) + { + result[parameter.Name] = new ExampleParameterValue(parameter.Name, type, GetBodyParameterValue()); + return true; + } + + // Request conditions / match conditions — default to null in samples. + if (type.Name == "RequestConditions" || + type.Name == "MatchConditions" || + type.Equals(ScmCodeModelGenerator.Instance.TypeFactory.MatchConditionsType)) + { + result[parameter.Name] = new ExampleParameterValue( + parameter.Name, + type, + Null.CastTo(type)); + return true; + } + + // ApiKeyCredential — produce `new ApiKeyCredential("")` + var keyCredentialType = ScmCodeModelGenerator.Instance.TypeFactory.ClientPipelineApi.KeyCredentialType; + if (keyCredentialType != null && (type.Equals(keyCredentialType) || type.Name == keyCredentialType.Name)) + { + result[parameter.Name] = new ExampleParameterValue( + parameter.Name, type, New.Instance(type, Literal(""))); + return true; + } + + // TokenCredential — produce `new DefaultAzureCredential()` + // TokenCredential is abstract, so we must use a concrete type. + var tokenCredentialType = ScmCodeModelGenerator.Instance.TypeFactory.ClientPipelineApi.TokenCredentialType; + if (tokenCredentialType != null && (type.Equals(tokenCredentialType) || type.Name == tokenCredentialType.Name)) + { + // Use FormattableStringExpression because DefaultAzureCredential + // lives in Azure.Identity which the generator doesn't reference. + result[parameter.Name] = new ExampleParameterValue( + parameter.Name, type, new FormattableStringExpression("new DefaultAzureCredential()", [])); + return true; + } + + // ClientOptions — skip (optional, not needed in sample). + // ScmKnownParameters.ClientOptions sets InitializationValue (not DefaultValue), + // so we must check both. + if (parameter.Name.EndsWith("Options", StringComparison.OrdinalIgnoreCase) && + (parameter.DefaultValue != null || parameter.InitializationValue != null)) + { + return true; + } + + return false; + } + + /// + /// Returns all the parameters that should be used in this sample. + /// Only required parameters are included if is false. + /// + private IEnumerable GetAllParameters() + { + // Parameters from the client invocation chain (ctor + factory methods) + foreach (var method in ClientInvocationChain) + { + foreach (var parameter in method.Parameters) + yield return parameter; + } + + // Parameters from the operation method itself + var operationParams = IsAllParametersUsed + ? _operationMethodSignature.Parameters + : _operationMethodSignature.Parameters.Where(p => p.DefaultValue == null); + + foreach (var parameter in operationParams) + yield return parameter; + } + + /// + /// Returns all parameter examples, handling spread parameters by extracting + /// individual properties from the model type. + /// + private IEnumerable GetAllParameterExamples() + { + foreach (var parameterExample in _example.Parameters) + { + var inputParameter = parameterExample.Parameter; + + // For spread parameters, the example value contains properties of the model + if (inputParameter is InputMethodParameter { Scope: InputParameterScope.Spread } && + inputParameter.Type is InputModelType modelType && + parameterExample.ExampleValue is InputExampleObjectValue objectValue) + { + var properties = objectValue.Values; + foreach (var modelOrBase in GetSelfAndBaseModels(modelType)) + { + foreach (var property in modelOrBase.Properties) + { + if (properties.TryGetValue(property.SerializedName, out var propValue)) + { + // Create a synthetic parameter example for each spread property + var syntheticParam = new InputMethodParameter( + property.Name, + null, // summary + property.Doc, + property.Type, + property.IsRequired, + property.IsReadOnly, + null, // access + property.SerializedName, + false, // isApiVersion + null, // defaultValue + InputParameterScope.Method, + InputRequestLocation.Body); + yield return new InputParameterExample(syntheticParam, propValue); + } + } + } + } + else + { + yield return parameterExample; + } + } + } + + /// + /// Searches for an example value by parameter name (case-sensitive). + /// + private static InputExampleValue? FindExampleValueByName( + IEnumerable parameterExamples, + string name) + { + foreach (var parameterExample in parameterExamples) + { + if (parameterExample.Parameter.Name == name) + { + return parameterExample.ExampleValue; + } + } + return null; + } + + /// + /// Gets the endpoint value, preferring the example value if available. + /// + private InputExampleValue GetEndpointValue(string parameterName) + { + // Try to find an endpoint value from the examples + var endpointExampleValue = _example.Parameters + .FirstOrDefault(e => e.Parameter is InputEndpointParameter)?.ExampleValue; + + if (endpointExampleValue != null) + return endpointExampleValue; + + // Fallback: placeholder + return InputExampleValue.Value(InputPrimitiveType.String, $"<{parameterName}>"); + } + + /// + /// Gets the body parameter value from the examples. + /// If there's a single body parameter example, use it. Otherwise search by type. + /// + private InputExampleValue GetBodyParameterValue() + { + var bodyParameters = _example.Parameters + .Where(e => e.Parameter is InputBodyParameter) + .ToArray(); + + if (bodyParameters.Length == 1) + { + return bodyParameters[0].ExampleValue; + } + + // Check for any body-located method parameter + var bodyMethodParam = _example.Parameters + .FirstOrDefault(e => e.Parameter is InputMethodParameter { Location: InputRequestLocation.Body }); + + if (bodyMethodParam != null) + { + return bodyMethodParam.ExampleValue; + } + + return InputExampleValue.Null(InputPrimitiveType.Any); + } + + /// + /// Walks the model and all its base models. + /// + private static IEnumerable GetSelfAndBaseModels(InputModelType model) + { + var current = model; + while (current != null) + { + yield return current; + current = current.BaseModel; + } + } + + // ------------------------------------------------------------------- + // Expression generation + // ------------------------------------------------------------------- + + /// + /// Converts the parameter value mapping entries to instances + /// for a specific set of parameters. Complex types are declared as out-of-line variables, + /// while simple types are inlined directly. + /// + public IEnumerable GetValueExpressionsForParameters( + IEnumerable parameters, + List variableDeclarationStatements) + { + foreach (var parameter in parameters) + { + // Skip ClientOptions-like parameters that should be omitted from samples. + // These have an InitializationValue (e.g. `options ??= new ClientOptions()`) but + // are optional and should not appear in sample code. We check before the mapping + // lookup because the mapping is keyed by name and a different parameter with the + // same name (e.g. the operation's RequestOptions "options") may exist in the map. + if (parameter.Name.EndsWith("Options", StringComparison.OrdinalIgnoreCase) && + (parameter.DefaultValue != null || parameter.InitializationValue != null)) + continue; + + ValueExpression parameterExpression; + + if (ParameterValueMapping.TryGetValue(parameter.Name, out var exampleValue)) + { + var format = parameter.WireInfo?.SerializationFormat ?? SerializationFormat.Default; + parameterExpression = ExampleValueExpressionBuilder.GetExpression(exampleValue, format); + } + else + { + // No example value — skip optional parameters (those with defaults or initialization values) + if (parameter.DefaultValue != null || parameter.InitializationValue != null) + continue; + + parameterExpression = DefaultOf(parameter.Type); + } + + if (IsInlineParameter(parameter)) + { + yield return parameterExpression; + } + else + { + // Declare variable out-of-line + var varRef = new VariableExpression(parameter.Type, parameter.Name); + var declaration = NeedsDispose(parameter) + ? UsingDeclare(varRef, parameterExpression) + : Declare(varRef, parameterExpression); + variableDeclarationStatements.Add(declaration); + yield return varRef; + } + } + } + + /// + /// Determines whether a parameter value should be inlined directly in the method call + /// or declared as a separate variable. + /// + private static bool IsInlineParameter(ParameterProvider parameter) + { + var type = parameter.Type; + + // Content parameters (BinaryContent/RequestContent) → out-of-line + if (parameter.IsContentParameter) + return false; + + // Endpoint → out-of-line + if (type.Equals(typeof(Uri))) + return false; + + // Credentials → out-of-line + var keyCredentialType = ScmCodeModelGenerator.Instance.TypeFactory.ClientPipelineApi.KeyCredentialType; + var tokenCredentialType = ScmCodeModelGenerator.Instance.TypeFactory.ClientPipelineApi.TokenCredentialType; + if ((keyCredentialType != null && (type.Equals(keyCredentialType) || type.Name == keyCredentialType.Name)) || + (tokenCredentialType != null && (type.Equals(tokenCredentialType) || type.Name == tokenCredentialType.Name))) + return false; + + // Model types (non-framework, non-enum, non-collection) → out-of-line + if (!type.IsFrameworkType && !type.IsEnum && !type.IsList && !type.IsDictionary) + return false; + + // Everything else (primitives, enums, collections) → inline + return true; + } + + /// + /// Determines whether a parameter needs a using declaration for disposal. + /// + private static bool NeedsDispose(ParameterProvider parameter) + { + return parameter.IsContentParameter; + } + + // ------------------------------------------------------------------- + // Response type resolution + // ------------------------------------------------------------------- + + /// + /// Returns the effective response type. + /// For paging operations, unwraps the item type from the response model. + /// For non-paging operations, returns the response type directly. + /// + private InputType? GetEffectiveResponseType() + { + var responseType = _serviceMethod.Response?.Type; + + if (_serviceMethod is not InputPagingServiceMethod pagingMethod) + return responseType; + + // For paging, try to unwrap the item type from the response model + var itemSegments = pagingMethod.PagingMetadata.ItemPropertySegments; + if (itemSegments.Count == 0 || responseType is not InputModelType responseModel) + return responseType; + + // Walk the item property path to find the items array + InputType currentType = responseModel; + foreach (var segment in itemSegments) + { + if (currentType is not InputModelType currentModel) + break; + + var property = currentModel.Properties + .FirstOrDefault(p => p.SerializedName == segment || p.Name == segment); + if (property == null) + break; + + currentType = property.Type; + } + + // If we found an array type at the end of the path, return the element type + if (currentType is InputArrayType arrayType) + return arrayType.ValueType; + + return responseType; + } + + // ------------------------------------------------------------------- + // Static helpers for sample generation decisions + // ------------------------------------------------------------------- + + /// + /// Determines whether samples should be generated for the given method. + /// + public static bool ShouldGenerateSample(ClientProvider client, MethodSignature protocolSignature) + { + if (!protocolSignature.Modifiers.HasFlag(MethodSignatureModifiers.Public)) + return false; + + // Check for obsolete + if (protocolSignature.Attributes.Any(a => a.Type.Equals(typeof(ObsoleteAttribute)))) + return false; + + // Subclients are always valid; root clients need a public constructor + bool isSubClient = client.InputClient.Parent != null; + if (isSubClient) + return true; + + return client.Constructors.Any(c => + c.Signature.Modifiers.HasFlag(MethodSignatureModifiers.Public)); + } + + /// + /// Determines whether the ShortVersion sample should be generated. + /// If protocol and convenience signatures are effectively identical, skip ShortVersion for protocol + /// to avoid duplicate samples. + /// + public static bool ShouldGenerateShortVersion(ScmMethodProviderCollection methodCollection) + { + var protocolMethod = methodCollection.MethodProviders + .FirstOrDefault(m => m.Kind == ScmMethodKind.Protocol && + !m.Signature.Modifiers.HasFlag(MethodSignatureModifiers.Async)); + var convenienceMethod = methodCollection.MethodProviders + .FirstOrDefault(m => m.Kind == ScmMethodKind.Convenience && + !m.Signature.Modifiers.HasFlag(MethodSignatureModifiers.Async)); + + if (protocolMethod == null || convenienceMethod == null) + return true; + + var protocolParams = protocolMethod.Signature.Parameters; + var convenienceParams = convenienceMethod.Signature.Parameters; + + // If the convenience method has one fewer parameter (e.g., no CancellationToken) + // and all overlapping parameter types match, skip — they're effectively identical. + if (convenienceParams.Count == protocolParams.Count - 1 && convenienceParams.Count > 0 && + !convenienceParams.Last().Type.Equals(typeof(CancellationToken))) + { + bool allEqual = true; + for (int i = 0; i < convenienceParams.Count; i++) + { + if (!convenienceParams[i].Type.Equals(protocolParams[i].Type)) + { + allEqual = false; + break; + } + } + + if (allEqual) + return false; + } + + return true; + } + + // ------------------------------------------------------------------- + // Sample information (human-readable descriptions) + // ------------------------------------------------------------------- + + /// + /// Gets a human-readable description of what the sample demonstrates. + /// + public string GetSampleInformation(bool isAsync) + { + var methodName = isAsync + ? _operationMethodSignature.Name + "Async" + : _operationMethodSignature.Name; + + return IsConvenienceSample + ? GetSampleInformationForConvenience(methodName) + : GetSampleInformationForProtocol(methodName); + } + + private string GetSampleInformationForConvenience(string methodName) + { + if (IsAllParametersUsed) + return $"This sample shows how to call {methodName} with all parameters."; + return $"This sample shows how to call {methodName}."; + } + + private string GetSampleInformationForProtocol(string methodName) + { + if (IsAllParametersUsed) + { + var desc = GenerateParameterAndRequestContentDescription(_operationMethodSignature.Parameters); + var parseResult = HasResponseBody ? " and parse the result" : ""; + return $"This sample shows how to call {methodName} with all {desc}{parseResult}."; + } + return $"This sample shows how to call {methodName}{(HasResponseBody ? " and parse the result" : "")}."; + } + + private static string GenerateParameterAndRequestContentDescription(IReadOnlyList parameters) + { + var hasNonBodyParameter = parameters.Any(p => + p.Location != ParameterLocation.Body && p.Name != "options"); + var hasBodyParameter = parameters.Any(p => p.Location == ParameterLocation.Body); + + if (hasNonBodyParameter) + return hasBodyParameter ? "parameters and request content" : "parameters"; + return "request content"; + } + + private string GetDebuggerDisplay() + => $"Sample (Client: {_client.Name}, Method: {_operationMethodSignature.Name})"; + } +} diff --git a/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/src/ScmOutputLibrary.cs b/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/src/ScmOutputLibrary.cs index 13e43ad6a70..b68e9df9a29 100644 --- a/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/src/ScmOutputLibrary.cs +++ b/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/src/ScmOutputLibrary.cs @@ -2,7 +2,9 @@ // Licensed under the MIT License. using System.Collections.Generic; +using System.Linq; using Microsoft.TypeSpec.Generator.ClientModel.Providers; +using Microsoft.TypeSpec.Generator.ClientModel.Providers.Samples; using Microsoft.TypeSpec.Generator.Input; using Microsoft.TypeSpec.Generator.Primitives; using Microsoft.TypeSpec.Generator.Providers; @@ -78,6 +80,7 @@ protected override TypeProvider[] BuildTypeProviders() return [ ..baseTypes, ..BuildClientTypes(), + ..BuildSampleTypes(), ScmCodeModelGenerator.Instance.ModelSerializationExtensionsDefinition, ScmCodeModelGenerator.Instance.SerializationFormatDefinition, new TypeFormattersDefinition(), @@ -102,5 +105,38 @@ private IEnumerable GetMultipartFormDataBinaryContentDefinition() yield return multipart; } } + + private static IEnumerable BuildSampleTypes() + { + var inputClients = ScmCodeModelGenerator.Instance.InputLibrary.InputNamespace.RootClients; + foreach (var inputClient in inputClients) + { + foreach (var provider in BuildSampleTypesForClient(inputClient)) + { + yield return provider; + } + } + } + + private static IEnumerable BuildSampleTypesForClient(InputClient inputClient) + { + foreach (var child in inputClient.Children) + { + foreach (var provider in BuildSampleTypesForClient(child)) + { + yield return provider; + } + } + + var client = ScmCodeModelGenerator.Instance.TypeFactory.CreateClient(inputClient); + if (client == null) + yield break; + + var sampleProvider = new ClientSampleProvider(client); + if (!sampleProvider.IsEmpty) + { + yield return sampleProvider; + } + } } } diff --git a/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/test/Providers/Samples/ClientSampleProviderTests.cs b/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/test/Providers/Samples/ClientSampleProviderTests.cs new file mode 100644 index 00000000000..c295cfded68 --- /dev/null +++ b/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/test/Providers/Samples/ClientSampleProviderTests.cs @@ -0,0 +1,362 @@ +// Copyright (c) Microsoft Corporation. All rights reserved. +// Licensed under the MIT License. + +using System.Collections.Generic; +using System.Linq; +using System.Reflection; +using System.Threading.Tasks; +using Microsoft.TypeSpec.Generator.ClientModel.Providers; +using Microsoft.TypeSpec.Generator.ClientModel.Providers.Samples; +using Microsoft.TypeSpec.Generator.Input; +using Microsoft.TypeSpec.Generator.Primitives; +using Microsoft.TypeSpec.Generator.Tests.Common; +using NUnit.Framework; + +namespace Microsoft.TypeSpec.Generator.ClientModel.Tests.Providers.Samples +{ + public class ClientSampleProviderTests + { + [SetUp] + public void SetUp() + { + MockHelpers.LoadMockGenerator(); + } + + // ------------------------------------------------------------------- + // Basic structure + // ------------------------------------------------------------------- + + [Test] + public void Name_FollowsSamplesConvention() + { + var (provider, _) = CreateProviderWithSingleExample("GetWidget"); + Assert.AreEqual("Samples_TestClient", provider.Name); + } + + [Test] + public void RelativeFilePath_IsInTestsGeneratedSamples() + { + var (provider, _) = CreateProviderWithSingleExample("GetWidget"); + Assert.IsTrue(provider.RelativeFilePath.Contains("tests")); + Assert.IsTrue(provider.RelativeFilePath.Contains("Samples")); + Assert.IsTrue(provider.RelativeFilePath.EndsWith(".cs")); + } + + [Test] + public void DeclarationModifiers_ArePublicPartial() + { + var (provider, _) = CreateProviderWithSingleExample("GetWidget"); + Assert.IsTrue(provider.DeclarationModifiers.HasFlag(TypeSignatureModifiers.Public)); + Assert.IsTrue(provider.DeclarationModifiers.HasFlag(TypeSignatureModifiers.Partial)); + } + + // ------------------------------------------------------------------- + // Method generation + // ------------------------------------------------------------------- + + [Test] + public void GeneratesSyncAndAsyncMethodPerSample() + { + var (provider, _) = CreateProviderWithSingleExample("GetWidget"); + var methods = provider.Methods; + + // Each sample should produce sync + async = 2 methods + Assert.IsTrue(methods.Count >= 2); + + // Should have at least one async and one sync method + Assert.IsTrue(methods.Any(m => + m.Signature.Modifiers.HasFlag(MethodSignatureModifiers.Async))); + Assert.IsTrue(methods.Any(m => + !m.Signature.Modifiers.HasFlag(MethodSignatureModifiers.Async))); + } + + [Test] + public void AsyncMethods_ReturnTask() + { + var (provider, _) = CreateProviderWithSingleExample("GetWidget"); + var asyncMethods = provider.Methods + .Where(m => m.Signature.Modifiers.HasFlag(MethodSignatureModifiers.Async)) + .ToList(); + + foreach (var method in asyncMethods) + { + Assert.IsNotNull(method.Signature.ReturnType); + Assert.AreEqual(typeof(Task), method.Signature.ReturnType!.FrameworkType); + } + } + + [Test] + public void SyncMethods_ReturnVoid() + { + var (provider, _) = CreateProviderWithSingleExample("GetWidget"); + var syncMethods = provider.Methods + .Where(m => !m.Signature.Modifiers.HasFlag(MethodSignatureModifiers.Async)) + .ToList(); + + foreach (var method in syncMethods) + { + Assert.IsNull(method.Signature.ReturnType); + } + } + + [Test] + public void MethodNames_ContainOperationNameAndExampleKey() + { + var (provider, _) = CreateProviderWithSingleExample("GetWidget"); + + foreach (var method in provider.Methods) + { + Assert.IsTrue(method.Signature.Name.Contains("GetWidget"), + $"Method name '{method.Signature.Name}' should contain 'GetWidget'"); + Assert.IsTrue(method.Signature.Name.Contains("ShortVersion"), + $"Method name '{method.Signature.Name}' should contain 'ShortVersion'"); + } + } + + [Test] + public void AsyncMethodNames_EndWithAsync() + { + var (provider, _) = CreateProviderWithSingleExample("GetWidget"); + var asyncMethods = provider.Methods + .Where(m => m.Signature.Modifiers.HasFlag(MethodSignatureModifiers.Async)) + .ToList(); + + foreach (var method in asyncMethods) + { + Assert.IsTrue(method.Signature.Name.EndsWith("_Async"), + $"Async method name '{method.Signature.Name}' should end with '_Async'"); + } + } + + // ------------------------------------------------------------------- + // Attributes + // ------------------------------------------------------------------- + + [Test] + public void Methods_HaveTestAttribute() + { + var (provider, _) = CreateProviderWithSingleExample("GetWidget"); + + foreach (var method in provider.Methods) + { + Assert.IsTrue( + method.Signature.Attributes.Any(a => a.Type.Name == "TestAttribute"), + $"Method '{method.Signature.Name}' should have [Test] attribute"); + } + } + + [Test] + public void Methods_HaveIgnoreAttribute() + { + var (provider, _) = CreateProviderWithSingleExample("GetWidget"); + + foreach (var method in provider.Methods) + { + Assert.IsTrue( + method.Signature.Attributes.Any(a => a.Type.Name == "IgnoreAttribute"), + $"Method '{method.Signature.Name}' should have [Ignore] attribute"); + } + } + + // ------------------------------------------------------------------- + // Method body + // ------------------------------------------------------------------- + + [Test] + public void MethodBody_IsNotEmpty() + { + var (provider, _) = CreateProviderWithSingleExample("GetWidget"); + + foreach (var method in provider.Methods) + { + Assert.IsNotNull(method.BodyStatements, + $"Method '{method.Signature.Name}' should have a body"); + } + } + + // ------------------------------------------------------------------- + // No examples → synthesizes default samples + // ------------------------------------------------------------------- + + [Test] + public void NoExamples_SynthesizesDefault() + { + var operation = InputFactory.Operation("GetWidget"); + var serviceMethod = InputFactory.BasicServiceMethod("GetWidget", operation); + var inputClient = InputFactory.Client("TestClient", methods: [serviceMethod]); + + MockHelpers.LoadMockGenerator(clients: () => [inputClient]); + + var client = ScmCodeModelGenerator.Instance.TypeFactory.CreateClient(inputClient)!; + var provider = new ClientSampleProvider(client); + + Assert.IsFalse(provider.IsEmpty); + Assert.IsTrue(provider.Methods.Count >= 2, "Should have at least sync+async methods"); + } + + // ------------------------------------------------------------------- + // Multiple examples → multiply methods + // ------------------------------------------------------------------- + + [Test] + public void MultipleExamples_GenerateMultipleMethods() + { + var shortVersion = new InputOperationExample("ShortVersion", null, [], ""); + var allParameters = new InputOperationExample("AllParameters", null, [], ""); + + var operation = InputFactory.Operation("GetWidget"); + SetOperationExamples(operation, [shortVersion, allParameters]); + var serviceMethod = InputFactory.BasicServiceMethod("GetWidget", operation); + var inputClient = InputFactory.Client("TestClient", methods: [serviceMethod]); + + MockHelpers.LoadMockGenerator(clients: () => [inputClient]); + + var client = ScmCodeModelGenerator.Instance.TypeFactory.CreateClient(inputClient)!; + var provider = new ClientSampleProvider(client); + + // Each sample (protocol/convenience) × 2 (sync/async) examples + Assert.IsTrue(provider.Methods.Count >= 4, + $"Expected at least 4 methods but got {provider.Methods.Count}"); + } + + // ------------------------------------------------------------------- + // Convenience methods suffixed + // ------------------------------------------------------------------- + + [Test] + public void ConvenienceMethods_HaveConvenienceSuffix() + { + var (provider, _) = CreateProviderWithSingleExample("GetWidget"); + var convenienceMethods = provider.Methods + .Where(m => m.Signature.Name.Contains("_Convenience")) + .ToList(); + + // All convenience-named methods should follow the naming pattern + foreach (var method in convenienceMethods) + { + Assert.IsTrue(method.Signature.Name.Contains("GetWidget"), + $"Convenience method '{method.Signature.Name}' should contain the operation name"); + } + } + + // ------------------------------------------------------------------- + // No parameters on sample methods + // ------------------------------------------------------------------- + + [Test] + public void SampleMethods_HaveNoParameters() + { + var (provider, _) = CreateProviderWithSingleExample("GetWidget"); + + foreach (var method in provider.Methods) + { + Assert.AreEqual(0, method.Signature.Parameters.Count, + $"Method '{method.Signature.Name}' should have no parameters"); + } + } + + // ------------------------------------------------------------------- + // BuildSamplesForOperation behavior + // ------------------------------------------------------------------- + + [Test] + public void BuildSamplesForOperation_AttachesProtocolAndConvenienceSamplesForEachExample() + { + var shortVersion = new InputOperationExample("ShortVersion", null, [], ""); + var allParameters = new InputOperationExample("AllParameters", null, [], ""); + var operation = InputFactory.Operation("GetWidget"); + SetOperationExamples(operation, [shortVersion, allParameters]); + var serviceMethod = InputFactory.BasicServiceMethod("GetWidget", operation); + var inputClient = InputFactory.Client("TestClient", methods: [serviceMethod]); + + MockHelpers.LoadMockGenerator(clients: () => [inputClient]); + + var client = ScmCodeModelGenerator.Instance.TypeFactory.CreateClient(inputClient)!; + var methodCollection = new ScmMethodProviderCollection(serviceMethod, client); + var provider = new ClientSampleProvider(client); + + bool shouldGenerateShortVersion = OperationSample.ShouldGenerateShortVersion(methodCollection); + + // Each sample generates sync + async = 2 methods + // With convenience: AllParameters (protocol+convenience) + ShortVersion (protocol+convenience if applicable) + var methods = provider.Methods; + Assert.IsTrue(methods.Any(m => m.Signature.Name.Contains("AllParameters") && !m.Signature.Name.Contains("Convenience"))); + Assert.IsTrue(methods.Any(m => m.Signature.Name.Contains("AllParameters") && m.Signature.Name.Contains("Convenience"))); + + if (shouldGenerateShortVersion) + { + Assert.IsTrue(methods.Any(m => m.Signature.Name.Contains("ShortVersion") && !m.Signature.Name.Contains("Convenience"))); + } + else + { + Assert.IsFalse(methods.Any(m => m.Signature.Name.Contains("ShortVersion") && !m.Signature.Name.Contains("Convenience"))); + } + } + + [Test] + public void BuildSamplesForOperation_DoesNotAttachConvenienceSamplesWhenConvenienceMethodIsDisabled() + { + var operation = InputFactory.Operation("GetWidget", generateConvenienceMethod: false); + SetOperationExamples( + operation, + [ + new InputOperationExample("ShortVersion", null, [], ""), + new InputOperationExample("AllParameters", null, [], "") + ]); + var serviceMethod = InputFactory.BasicServiceMethod("GetWidget", operation); + var inputClient = InputFactory.Client("TestClient", methods: [serviceMethod]); + + MockHelpers.LoadMockGenerator(clients: () => [inputClient]); + + var client = ScmCodeModelGenerator.Instance.TypeFactory.CreateClient(inputClient)!; + var provider = new ClientSampleProvider(client); + + // No convenience methods should be generated + Assert.IsFalse(provider.Methods.Any(m => m.Signature.Name.Contains("Convenience"))); + } + + [Test] + public void BuildSamplesForOperation_WithoutExamples_SynthesizesDefault() + { + var operation = InputFactory.Operation("GetWidget"); + var serviceMethod = InputFactory.BasicServiceMethod("GetWidget", operation); + var inputClient = InputFactory.Client("TestClient", methods: [serviceMethod]); + + MockHelpers.LoadMockGenerator(clients: () => [inputClient]); + + var client = ScmCodeModelGenerator.Instance.TypeFactory.CreateClient(inputClient)!; + var provider = new ClientSampleProvider(client); + + Assert.IsNotEmpty(provider.Methods); + Assert.IsTrue(provider.Methods.Any(m => m.Signature.Name.Contains("ShortVersion"))); + } + + // ------------------------------------------------------------------- + // Helpers + // ------------------------------------------------------------------- + + private static (ClientSampleProvider provider, ClientProvider client) CreateProviderWithSingleExample( + string operationName) + { + var shortVersion = new InputOperationExample("ShortVersion", null, [], ""); + var operation = InputFactory.Operation(operationName); + SetOperationExamples(operation, [shortVersion]); + var serviceMethod = InputFactory.BasicServiceMethod(operationName, operation); + var inputClient = InputFactory.Client("TestClient", methods: [serviceMethod]); + + MockHelpers.LoadMockGenerator(clients: () => [inputClient]); + + var client = ScmCodeModelGenerator.Instance.TypeFactory.CreateClient(inputClient)!; + var provider = new ClientSampleProvider(client); + return (provider, client); + } + + private static void SetOperationExamples(InputOperation operation, IReadOnlyList examples) + { + var setter = typeof(InputOperation) + .GetProperty(nameof(InputOperation.Examples), BindingFlags.Instance | BindingFlags.Public)! + .GetSetMethod(nonPublic: true)!; + setter.Invoke(operation, [examples]); + } + } +} diff --git a/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/test/Providers/Samples/ExampleValueExpressionBuilderTests.cs b/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/test/Providers/Samples/ExampleValueExpressionBuilderTests.cs new file mode 100644 index 00000000000..8daea57ac77 --- /dev/null +++ b/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/test/Providers/Samples/ExampleValueExpressionBuilderTests.cs @@ -0,0 +1,624 @@ +// Copyright (c) Microsoft Corporation. All rights reserved. +// Licensed under the MIT License. + +using System; +using System.Collections.Generic; +using System.IO; +using System.Text; +using System.Xml; +using Microsoft.TypeSpec.Generator.ClientModel.Providers.Samples; +using Microsoft.TypeSpec.Generator.Expressions; +using Microsoft.TypeSpec.Generator.Input; +using Microsoft.TypeSpec.Generator.Primitives; +using Microsoft.TypeSpec.Generator.Tests.Common; +using NUnit.Framework; + +namespace Microsoft.TypeSpec.Generator.ClientModel.Tests.Providers.Samples +{ + public class ExampleValueExpressionBuilderTests + { + // ----------------------------------------------------------------------- + // ExampleParameterValue — dual mode + // ----------------------------------------------------------------------- + + [Test] + public void ParameterValue_WithExpression_ReturnsExpression() + { + var expr = new LiteralExpression(42); + var paramValue = new ExampleParameterValue("count", new CSharpType(typeof(int)), expr); + + var result = ExampleValueExpressionBuilder.GetExpression(paramValue); + + Assert.AreSame(expr, result); + } + + [Test] + public void ParameterValue_WithValue_ConvertsToExpression() + { + var inputValue = InputExampleValue.Value(InputPrimitiveType.Int32, 1234); + var paramValue = new ExampleParameterValue("count", new CSharpType(typeof(int)), inputValue); + + var result = ExampleValueExpressionBuilder.GetExpression(paramValue); + + Assert.IsNotNull(result); + } + + [Test] + public void ParameterValue_WithNeither_ReturnsDefault() + { + // Edge case: both Value and Expression are null (shouldn't happen in practice) + var paramValue = new ExampleParameterValue("x", new CSharpType(typeof(int)), + (InputExampleValue)null!); + + // This will go through GetExpression with null value — should return Default + var result = ExampleValueExpressionBuilder.GetExpression(paramValue); + Assert.IsNotNull(result); + } + + // ----------------------------------------------------------------------- + // Framework type conversions — primitives + // ----------------------------------------------------------------------- + + [Test] + public void String_FromRawValue() + { + var result = BuildExpression(typeof(string), InputExampleValue.Value(InputPrimitiveType.String, "hello")); + Assert.IsNotNull(result); + // Should not be null/default + Assert.IsNotInstanceOf(result); + } + + [Test] + public void String_FromNull() + { + var result = BuildExpression(typeof(string), InputExampleValue.Null(InputPrimitiveType.String)); + // Null string → Null keyword + Assert.IsNotNull(result); + } + + [Test] + public void Bool_True() + { + var result = BuildExpression(typeof(bool), InputExampleValue.Value(InputPrimitiveType.Boolean, true)); + Assert.IsNotNull(result); + } + + [Test] + public void Int32_FromRawValue() + { + var result = BuildExpression(typeof(int), InputExampleValue.Value(InputPrimitiveType.Int32, 1234)); + Assert.IsNotNull(result); + } + + [Test] + public void Int64_FromRawValue() + { + var result = BuildExpression(typeof(long), InputExampleValue.Value(InputPrimitiveType.Int64, 1234L)); + Assert.IsNotNull(result); + } + + [Test] + public void Float_FromRawValue() + { + var result = BuildExpression(typeof(float), InputExampleValue.Value(InputPrimitiveType.Float32, 123.45f)); + Assert.IsNotNull(result); + } + + [Test] + public void Double_FromRawValue() + { + var result = BuildExpression(typeof(double), InputExampleValue.Value(InputPrimitiveType.Float64, 123.45)); + Assert.IsNotNull(result); + } + + [Test] + public void Decimal_FromRawValue() + { + var result = BuildExpression(typeof(decimal), InputExampleValue.Value( + new InputPrimitiveType(InputPrimitiveTypeKind.Decimal, "decimal", "TypeSpec.decimal"), 123.45m)); + Assert.IsNotNull(result); + } + + // ----------------------------------------------------------------------- + // Framework type conversions — complex types + // ----------------------------------------------------------------------- + + [Test] + public void Guid_FromString() + { + var result = BuildExpression(typeof(Guid), + InputExampleValue.Value(InputPrimitiveType.String, "73f411fe-4f43-4b4b-9cbd-6828d8f4cf9a")); + + // Should produce Guid.Parse("...") + Assert.IsInstanceOf(result); + } + + [Test] + public void Uri_FromString() + { + var result = BuildExpression(typeof(Uri), + InputExampleValue.Value(InputPrimitiveType.Url, "http://localhost:3000")); + + // Should produce new Uri("...") + Assert.IsNotNull(result); + } + + [Test] + public void DateTimeOffset_FromString() + { + var result = BuildExpression(typeof(DateTimeOffset), + InputExampleValue.Value(InputPrimitiveType.String, "2022-05-10T18:57:31.2311892Z")); + + // Should produce DateTimeOffset.Parse("...") + Assert.IsInstanceOf(result); + } + + [Test] + public void DateTimeOffset_FromUnixTimestamp() + { + var result = BuildExpression(typeof(DateTimeOffset), + InputExampleValue.Value(InputPrimitiveType.Int64, 1652209051L)); + + // Should produce DateTimeOffset.FromUnixTimeSeconds(...) + Assert.IsInstanceOf(result); + } + + [Test] + public void TimeSpan_FromIso8601String() + { + var result = BuildExpression(typeof(TimeSpan), + InputExampleValue.Value(InputPrimitiveType.String, "PT1H23M45S")); + + // Should produce XmlConvert.ToTimeSpan("...") + Assert.IsInstanceOf(result); + } + + [Test] + public void TimeSpan_FromSeconds() + { + var result = BuildExpression(typeof(TimeSpan), + InputExampleValue.Value(InputPrimitiveType.Float64, 10.5)); + + // Should produce TimeSpan.FromSeconds(...) + Assert.IsInstanceOf(result); + } + + [Test] + public void BinaryData_FromObject() + { + var objValue = InputExampleValue.Object( + InputFactory.Model("TestModel"), + new Dictionary + { + ["name"] = InputExampleValue.Value(InputPrimitiveType.String, "test") + }); + + var result = BuildExpression(typeof(BinaryData), objValue); + + // Should produce BinaryData.FromObjectAsJson(new { name = "test" }) + Assert.IsInstanceOf(result); + } + + [Test] + public void ByteArray_FromString() + { + var result = BuildExpression(typeof(byte[]), + InputExampleValue.Value(InputPrimitiveType.String, "dGVzdA==")); + + // Should produce Encoding.UTF8.GetBytes("...") + Assert.IsInstanceOf(result); + } + + [Test] + public void Stream_FromStreamValue() + { + var result = BuildExpression(typeof(Stream), + InputExampleValue.Stream(InputPrimitiveType.String, "")); + + // Should produce File.OpenRead("...") + Assert.IsInstanceOf(result); + } + + // ----------------------------------------------------------------------- + // Collections + // ----------------------------------------------------------------------- + + [Test] + public void List_FromListValue() + { + var listType = new CSharpType(typeof(IList<>), new CSharpType(typeof(int))); + var listValue = InputExampleValue.List( + new InputArrayType("list", "TypeSpec.Array", InputPrimitiveType.Int32), + new[] { InputExampleValue.Value(InputPrimitiveType.Int32, 1234) }); + + var result = ExampleValueExpressionBuilder.GetExpression(listType, listValue); + + // New.Array returns IndexableExpression wrapping NewArrayExpression + Assert.IsNotNull(result); + } + + [Test] + public void Dictionary_FromObjectValue() + { + var dictType = new CSharpType(typeof(IDictionary<,>), new CSharpType(typeof(string)), new CSharpType(typeof(int))); + var dictValue = InputExampleValue.Object( + new InputDictionaryType("dict", InputPrimitiveType.String, InputPrimitiveType.Int32), + new Dictionary + { + ["key"] = InputExampleValue.Value(InputPrimitiveType.Int32, 42) + }); + + var result = ExampleValueExpressionBuilder.GetExpression(dictType, dictValue); + + // New.Dictionary returns DictionaryExpression wrapping NewInstanceExpression + Assert.IsNotNull(result); + } + + // ----------------------------------------------------------------------- + // Enum + // ----------------------------------------------------------------------- + + [Test] + public void Enum_ProducesMemberAccess() + { + // Use a real framework enum type for testing + var enumType = new CSharpType(typeof(DayOfWeek)); + var value = InputExampleValue.Value( + InputFactory.StringEnum("DayOfWeek", [("Monday", "Monday")]), "Monday"); + + var result = ExampleValueExpressionBuilder.GetExpression(enumType, value); + + // Should produce a member expression like DayOfWeek.Monday + Assert.IsInstanceOf(result); + } + + // ----------------------------------------------------------------------- + // Model (basic) + // ----------------------------------------------------------------------- + + [Test] + public void Model_ProducesNewInstance() + { + var modelType = new CSharpType(typeof(object)); + var value = InputExampleValue.Object( + InputFactory.Model("Widget"), + new Dictionary()); + + var result = ExampleValueExpressionBuilder.GetExpression(modelType, value); + + // Non-collection, non-enum framework type falls through to framework handler + Assert.IsNotNull(result); + } + + // ----------------------------------------------------------------------- + // Anonymous object (for BinaryContent) + // ----------------------------------------------------------------------- + + [Test] + public void AnonymousObject_FromNestedValues() + { + var objValue = InputExampleValue.Object( + InputFactory.Model("Request"), + new Dictionary + { + ["name"] = InputExampleValue.Value(InputPrimitiveType.String, "test"), + ["count"] = InputExampleValue.Value(InputPrimitiveType.Int32, 5) + }); + + var result = ExampleValueExpressionBuilder.GetExpressionForAnonymousObject(objValue); + + // Should produce new { name = "test", count = 5 } + Assert.IsNotNull(result); + } + + [Test] + public void AnonymousObject_SkipsNullValues() + { + var objValue = InputExampleValue.Object( + InputFactory.Model("Request"), + new Dictionary + { + ["name"] = InputExampleValue.Value(InputPrimitiveType.String, "test"), + ["nullable"] = InputExampleValue.Null(InputPrimitiveType.String) + }); + + var result = ExampleValueExpressionBuilder.GetExpressionForAnonymousObject(objValue); + + // Should produce new { name = "test" } — nullable skipped + Assert.IsNotNull(result); + } + + [Test] + public void AnonymousObject_EmptyObject() + { + var objValue = InputExampleValue.Object( + InputFactory.Model("Empty"), + new Dictionary()); + + var result = ExampleValueExpressionBuilder.GetExpressionForAnonymousObject(objValue); + + // Empty object → new object() (wrapped in ScopedApi) + Assert.IsNotNull(result); + } + + // ----------------------------------------------------------------------- + // Null / default fallbacks + // ----------------------------------------------------------------------- + + [Test] + public void Null_ValueType_ReturnsDefault() + { + var result = BuildExpression(typeof(int), InputExampleValue.Null(InputPrimitiveType.Int32)); + Assert.IsInstanceOf(result); + } + + [Test] + public void Null_ReferenceType_ReturnsNull() + { + var result = BuildExpression(typeof(string), InputExampleValue.Null(InputPrimitiveType.String)); + Assert.IsInstanceOf(result); + } + + // ----------------------------------------------------------------------- + // Missing primitive types — cast expressions + // ----------------------------------------------------------------------- + + [Test] + public void Short_FromRawValue() + { + var result = BuildExpression(typeof(short), InputExampleValue.Value( + new InputPrimitiveType(InputPrimitiveTypeKind.Int16, "int16", "TypeSpec.int16"), (short)1234)); + Assert.IsNotNull(result); + Assert.IsInstanceOf(result); + } + + [Test] + public void SByte_FromRawValue() + { + var result = BuildExpression(typeof(sbyte), InputExampleValue.Value( + new InputPrimitiveType(InputPrimitiveTypeKind.Int8, "int8", "TypeSpec.int8"), (sbyte)123)); + Assert.IsNotNull(result); + Assert.IsInstanceOf(result); + } + + [Test] + public void Byte_FromRawValue() + { + var result = BuildExpression(typeof(byte), InputExampleValue.Value( + new InputPrimitiveType(InputPrimitiveTypeKind.UInt8, "uint8", "TypeSpec.uint8"), (byte)123)); + Assert.IsNotNull(result); + Assert.IsInstanceOf(result); + } + + [Test] + public void UShort_FromRawValue() + { + var result = BuildExpression(typeof(ushort), InputExampleValue.Value( + new InputPrimitiveType(InputPrimitiveTypeKind.UInt16, "uint16", "TypeSpec.uint16"), (ushort)1234)); + Assert.IsNotNull(result); + Assert.IsInstanceOf(result); + } + + [Test] + public void UInt_FromRawValue() + { + var result = BuildExpression(typeof(uint), InputExampleValue.Value( + new InputPrimitiveType(InputPrimitiveTypeKind.UInt32, "uint32", "TypeSpec.uint32"), (uint)1234)); + Assert.IsNotNull(result); + Assert.IsInstanceOf(result); + } + + [Test] + public void ULong_FromRawValue() + { + var result = BuildExpression(typeof(ulong), InputExampleValue.Value( + new InputPrimitiveType(InputPrimitiveTypeKind.UInt64, "uint64", "TypeSpec.uint64"), (ulong)1234)); + Assert.IsNotNull(result); + Assert.IsInstanceOf(result); + } + + // ----------------------------------------------------------------------- + // Null paths for complex types + // ----------------------------------------------------------------------- + + [Test] + public void Bool_Null_ReturnsDefault() + { + var result = BuildExpression(typeof(bool), InputExampleValue.Null(InputPrimitiveType.Boolean)); + Assert.IsInstanceOf(result); + } + + [Test] + public void Guid_Null_ReturnsDefault() + { + var result = BuildExpression(typeof(Guid), InputExampleValue.Null(InputPrimitiveType.String)); + Assert.IsInstanceOf(result); + } + + [Test] + public void Uri_Null_ReturnsNull() + { + var result = BuildExpression(typeof(Uri), InputExampleValue.Null(InputPrimitiveType.String)); + Assert.IsNotNull(result); + } + + [Test] + public void DateTimeOffset_Null_ReturnsDefault() + { + var result = BuildExpression(typeof(DateTimeOffset), InputExampleValue.Null(InputPrimitiveType.String)); + Assert.IsInstanceOf(result); + } + + [Test] + public void TimeSpan_Null_ReturnsDefault() + { + var result = BuildExpression(typeof(TimeSpan), InputExampleValue.Null(InputPrimitiveType.String)); + Assert.IsInstanceOf(result); + } + + [Test] + public void ByteArray_Null_ReturnsNull() + { + var result = BuildExpression(typeof(byte[]), InputExampleValue.Null(InputPrimitiveType.String)); + Assert.IsNotNull(result); + } + + [Test] + public void Stream_NonStreamValue_ReturnsNull() + { + var result = BuildExpression(typeof(Stream), InputExampleValue.Value(InputPrimitiveType.String, "notastream")); + Assert.IsNotNull(result); + } + + // ----------------------------------------------------------------------- + // Enum edge case + // ----------------------------------------------------------------------- + + [Test] + public void Enum_Null_ReturnsDefault() + { + var enumType = new CSharpType(typeof(DayOfWeek)); + var value = InputExampleValue.Null(InputFactory.StringEnum("DayOfWeek", [("Monday", "Monday")])); + + var result = ExampleValueExpressionBuilder.GetExpression(enumType, value); + + Assert.IsInstanceOf(result); + } + + // ----------------------------------------------------------------------- + // Collection edge cases + // ----------------------------------------------------------------------- + + [Test] + public void List_FromNonListValue_ReturnsEmptyArray() + { + var listType = new CSharpType(typeof(IList<>), new CSharpType(typeof(int))); + var nonListValue = InputExampleValue.Value(InputPrimitiveType.Int32, 1234); + + var result = ExampleValueExpressionBuilder.GetExpression(listType, nonListValue); + + // Should produce an empty array + Assert.IsNotNull(result); + } + + [Test] + public void Dictionary_FromNonObjectValue_ReturnsEmptyDictionary() + { + var dictType = new CSharpType(typeof(IDictionary<,>), new CSharpType(typeof(string)), new CSharpType(typeof(int))); + var nonObjValue = InputExampleValue.Value(InputPrimitiveType.Int32, 1234); + + var result = ExampleValueExpressionBuilder.GetExpression(dictType, nonObjValue); + + // Should produce an empty dictionary + Assert.IsNotNull(result); + } + + // ----------------------------------------------------------------------- + // Model edge case + // ----------------------------------------------------------------------- + + [Test] + public void Model_ValueType_ReturnsDefault() + { + var valueType = new CSharpType(typeof(int)); // value type but not enum/collection/known + var value = InputExampleValue.Object( + InputFactory.Model("Widget"), + new Dictionary()); + + // int is a framework type, so it goes to framework handler, not model handler + var result = ExampleValueExpressionBuilder.GetExpression(valueType, value); + Assert.IsNotNull(result); + } + + // ----------------------------------------------------------------------- + // Anonymous object edge cases + // ----------------------------------------------------------------------- + + [Test] + public void AnonymousObject_WithNestedList() + { + var listValue = InputExampleValue.List( + new InputArrayType("list", "TypeSpec.Array", InputPrimitiveType.String), + new[] { InputExampleValue.Value(InputPrimitiveType.String, "item1") }); + + var objValue = InputExampleValue.Object( + InputFactory.Model("Request"), + new Dictionary + { + ["items"] = listValue + }); + + var result = ExampleValueExpressionBuilder.GetExpressionForAnonymousObject(objValue); + Assert.IsNotNull(result); + } + + [Test] + public void AnonymousObject_WithNestedObject() + { + var innerObj = InputExampleValue.Object( + InputFactory.Model("Inner"), + new Dictionary + { + ["innerProp"] = InputExampleValue.Value(InputPrimitiveType.Int32, 42) + }); + + var outerObj = InputExampleValue.Object( + InputFactory.Model("Outer"), + new Dictionary + { + ["nested"] = innerObj + }); + + var result = ExampleValueExpressionBuilder.GetExpressionForAnonymousObject(outerObj); + Assert.IsNotNull(result); + } + + [Test] + public void AnonymousObject_FromRawPrimitive() + { + var rawValue = InputExampleValue.Value(InputPrimitiveType.String, "hello"); + + var result = ExampleValueExpressionBuilder.GetExpressionForAnonymousObject(rawValue); + Assert.IsNotNull(result); + } + + [Test] + public void AnonymousObject_FromNullRaw() + { + var nullValue = InputExampleValue.Null(InputPrimitiveType.String); + + var result = ExampleValueExpressionBuilder.GetExpressionForAnonymousObject(nullValue); + // Should return Null keyword + Assert.IsNotNull(result); + } + + // ----------------------------------------------------------------------- + // Fallback for unknown framework types + // ----------------------------------------------------------------------- + + [Test] + public void UnknownValueType_ReturnsDefault() + { + // A value type that doesn't match any specific handler + var result = BuildExpression(typeof(DateTime), InputExampleValue.Null(InputPrimitiveType.String)); + Assert.IsInstanceOf(result); + } + + [Test] + public void UnknownReferenceType_ReturnsNull() + { + // A reference type that doesn't match any specific handler + var result = BuildExpression(typeof(System.Text.StringBuilder), InputExampleValue.Null(InputPrimitiveType.String)); + Assert.IsNotNull(result); + } + + // ----------------------------------------------------------------------- + // Helpers + // ----------------------------------------------------------------------- + + private static ValueExpression BuildExpression(Type frameworkType, InputExampleValue value) + { + return ExampleValueExpressionBuilder.GetExpression(new CSharpType(frameworkType), value); + } + } +} diff --git a/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/test/Providers/Samples/OperationSampleTests.cs b/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/test/Providers/Samples/OperationSampleTests.cs new file mode 100644 index 00000000000..dcec8a22bbf --- /dev/null +++ b/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/test/Providers/Samples/OperationSampleTests.cs @@ -0,0 +1,387 @@ +// Copyright (c) Microsoft Corporation. All rights reserved. +// Licensed under the MIT License. + +using System.Collections.Generic; +using System.Linq; +using System; +using System.Reflection; +using Microsoft.TypeSpec.Generator.ClientModel.Providers; +using Microsoft.TypeSpec.Generator.ClientModel.Providers.Samples; +using Microsoft.TypeSpec.Generator.Expressions; +using Microsoft.TypeSpec.Generator.Input; +using Microsoft.TypeSpec.Generator.Primitives; +using Microsoft.TypeSpec.Generator.Snippets; +using Microsoft.TypeSpec.Generator.Tests.Common; +using NUnit.Framework; + +namespace Microsoft.TypeSpec.Generator.ClientModel.Tests.Providers.Samples +{ + public class OperationSampleTests + { + [SetUp] + public void SetUp() + { + MockHelpers.LoadMockGenerator(); + } + + // ------------------------------------------------------------------- + // TokenCredential → new DefaultAzureCredential() + // ------------------------------------------------------------------- + + [Test] + public void TokenCredential_ProducesDefaultAzureCredential() + { + var sample = CreateSampleWithClientParameterType("credential", new CSharpType(typeof(TokenCredential))); + var mapping = sample.ParameterValueMapping; + + Assert.IsTrue(mapping.ContainsKey("credential")); + + // The expression should be a FormattableStringExpression containing "new DefaultAzureCredential()" + // (not "new TokenCredential()" which would fail because TokenCredential is abstract) + var expr = ExampleValueExpressionBuilder.GetExpression(mapping["credential"]); + Assert.IsInstanceOf(expr); + + // Verify the format string is exactly "new DefaultAzureCredential()" via reflection + // (Format is private, but this is the key parity assertion) + var formatProp = typeof(FormattableStringExpression).GetProperty("Format", BindingFlags.NonPublic | BindingFlags.Instance); + Assert.IsNotNull(formatProp, "Format property should exist on FormattableStringExpression"); + Assert.AreEqual("new DefaultAzureCredential()", formatProp!.GetValue(expr)); + } + + // ------------------------------------------------------------------- + // ApiKeyCredential → new AzureKeyCredential("") + // ------------------------------------------------------------------- + + [Test] + public void ApiKeyCredential_ProducesNewWithKeyPlaceholder() + { + var sample = CreateSampleWithClientParameterType("credential", new CSharpType(typeof(AzureKeyCredential))); + var mapping = sample.ParameterValueMapping; + + Assert.IsTrue(mapping.ContainsKey("credential")); + + var expr = Unwrap(UnwrapCast(ExampleValueExpressionBuilder.GetExpression(mapping["credential"]))); + Assert.IsInstanceOf(expr); + + var newExpr = (NewInstanceExpression)expr; + Assert.AreEqual(1, newExpr.Parameters.Count); + // The argument should be the literal "" + var argExpr = Unwrap(newExpr.Parameters[0]); + Assert.IsInstanceOf(argExpr); + Assert.AreEqual("", ((LiteralExpression)argExpr).Literal); + } + + // ------------------------------------------------------------------- + // Endpoint value resolution + // ------------------------------------------------------------------- + + [Test] + public void Endpoint_WithoutExample_UsesPlaceholder() + { + var sample = CreateBasicSample("ShortVersion"); + var endpointValue = InvokeGetEndpointValue(sample, "endpoint"); + Assert.AreEqual("", GetRawExampleValue(endpointValue)); + } + + [Test] + public void Endpoint_WithExample_UsesProvidedUrl() + { + const string url = "https://example.contoso.test"; + var sample = CreateSampleWithEndpointExample("ShortVersion", url); + var endpointValue = InvokeGetEndpointValue(sample, "endpoint"); + Assert.AreEqual(url, GetRawExampleValue(endpointValue)); + } + + // ------------------------------------------------------------------- + // Client invocation chain — root client + // ------------------------------------------------------------------- + + [Test] + public void RootClient_ChainHasConstructor() + { + var sample = CreateBasicSample("ShortVersion"); + var chain = sample.ClientInvocationChain; + + Assert.IsTrue(chain.Count >= 1); + Assert.IsInstanceOf(chain[0]); + } + + // ------------------------------------------------------------------- + // Client invocation chain — subclient + // ------------------------------------------------------------------- + + [Test] + public void SubClient_ChainHasConstructorThenFactory() + { + var (sample, _, _) = CreateSubClientSample("ShortVersion"); + var chain = sample.ClientInvocationChain; + + Assert.IsTrue(chain.Count >= 2); + Assert.IsInstanceOf(chain[0], "First element should be root ctor"); + Assert.IsInstanceOf(chain[1], "Second element should be factory method"); + } + + // ------------------------------------------------------------------- + // Parameter mapping + // ------------------------------------------------------------------- + + [Test] + public void ParameterMapping_ExampleValue_IsMapped() + { + var bodyParam = InputFactory.MethodParameter("message", InputPrimitiveType.String, isRequired: true); + var example = new InputOperationExample( + "ShortVersion", + null, + [new InputParameterExample(bodyParam, InputExampleValue.Value(InputPrimitiveType.String, "hello"))], + ""); + + var operation = InputFactory.Operation("SendMessage", + parameters: [InputFactory.BodyParameter("message", InputPrimitiveType.String, isRequired: true)]); + var serviceMethod = InputFactory.BasicServiceMethod("SendMessage", operation, parameters: [bodyParam]); + var inputClient = InputFactory.Client("MsgClient", methods: [serviceMethod]); + + MockHelpers.LoadMockGenerator( + createCSharpTypeCore: (inputType) => new CSharpType(typeof(string))); + + var client = ScmCodeModelGenerator.Instance.TypeFactory.CreateClient(inputClient)!; + var methodCollection = new ScmMethodProviderCollection(serviceMethod, client); + var sample = new OperationSample(client, methodCollection, serviceMethod, example, true, "ShortVersion"); + + var mapping = sample.ParameterValueMapping; + Assert.IsTrue(mapping.ContainsKey("message")); + Assert.IsNotNull(mapping["message"].Value); + } + + // ------------------------------------------------------------------- + // Optional params excluded from ShortVersion + // ------------------------------------------------------------------- + + [Test] + public void ParameterMapping_OptionalParam_ExcludedFromShortVersion() + { + var optionalParam = InputFactory.MethodParameter("tag", InputPrimitiveType.String, isRequired: false, + defaultValue: InputFactory.Constant.String("default")); + var example = new InputOperationExample("ShortVersion", null, [], ""); + + var operation = InputFactory.Operation("GetItem", + parameters: [InputFactory.QueryParameter("tag", InputPrimitiveType.String, isRequired: false)]); + var serviceMethod = InputFactory.BasicServiceMethod("GetItem", operation, parameters: [optionalParam]); + var inputClient = InputFactory.Client("ItemClient", methods: [serviceMethod]); + + MockHelpers.LoadMockGenerator( + createCSharpTypeCore: (inputType) => new CSharpType(typeof(string))); + + var client = ScmCodeModelGenerator.Instance.TypeFactory.CreateClient(inputClient)!; + var methodCollection = new ScmMethodProviderCollection(serviceMethod, client); + var sample = new OperationSample(client, methodCollection, serviceMethod, example, true, "ShortVersion"); + + Assert.IsFalse(sample.ParameterValueMapping.ContainsKey("tag")); + } + + // ------------------------------------------------------------------- + // WaitUntil → .Completed + // ------------------------------------------------------------------- + + [Test] + public void WaitUntil_ProducesCompletedMemberAccess() + { + var sample = CreateSampleWithClientParameterType("waitUntil", new CSharpType(typeof(WaitUntil))); + var mapping = sample.ParameterValueMapping; + + Assert.IsTrue(mapping.ContainsKey("waitUntil")); + var expr = UnwrapCast(ExampleValueExpressionBuilder.GetExpression(mapping["waitUntil"])); + // Should be a property access like WaitUntil.Completed + Assert.IsInstanceOf(expr); + } + + // ------------------------------------------------------------------- + // RequestOptions (required) → null + // ------------------------------------------------------------------- + + [Test] + public void RequiredRequestOptions_ProducesNull() + { + var sample = CreateSampleWithClientParameterType( + "options", + new CSharpType(typeof(System.ClientModel.Primitives.RequestOptions)), + isOptional: false, + defaultValue: null); + var mapping = sample.ParameterValueMapping; + + Assert.IsTrue(mapping.ContainsKey("options")); + var expr = UnwrapCast(ExampleValueExpressionBuilder.GetExpression(mapping["options"])); + Assert.IsInstanceOf(expr); + } + + // ------------------------------------------------------------------- + // MatchConditions → null + // ------------------------------------------------------------------- + + [Test] + public void MatchConditions_ProducesNull() + { + var sample = CreateSampleWithClientParameterType("conditions", new CSharpType(typeof(MatchConditions))); + var mapping = sample.ParameterValueMapping; + + Assert.IsTrue(mapping.ContainsKey("conditions")); + var expr = UnwrapCast(ExampleValueExpressionBuilder.GetExpression(mapping["conditions"])); + Assert.IsInstanceOf(expr); + } + + // ------------------------------------------------------------------- + // ShouldGenerateShortVersion + // ------------------------------------------------------------------- + + [Test] + public void ShouldGenerateShortVersion_TrueWhenNoConvenience() + { + var operation = InputFactory.Operation("TestOp", generateConvenienceMethod: false); + var serviceMethod = InputFactory.BasicServiceMethod("TestOp", operation); + var inputClient = InputFactory.Client("TestClient", methods: [serviceMethod]); + + var client = ScmCodeModelGenerator.Instance.TypeFactory.CreateClient(inputClient)!; + var methodCollection = new ScmMethodProviderCollection(serviceMethod, client); + + Assert.IsTrue(OperationSample.ShouldGenerateShortVersion(methodCollection)); + } + + // ------------------------------------------------------------------- + // Sample metadata + // ------------------------------------------------------------------- + + [Test] + public void SampleInformation_ContainsMethodName() + { + var sample = CreateBasicSample("ShortVersion", isConvenience: true); + var info = sample.GetSampleInformation(false); + Assert.IsTrue(info.Contains("how to call")); + } + + [Test] + public void SampleInformation_AsyncAppendsAsync() + { + var sample = CreateBasicSample("ShortVersion", isConvenience: true); + var info = sample.GetSampleInformation(true); + Assert.IsTrue(info.Contains("Async")); + } + + // ------------------------------------------------------------------- + // Helpers + // ------------------------------------------------------------------- + + private static OperationSample CreateBasicSample(string exampleKey, bool isConvenience = false) + { + var operation = InputFactory.Operation("TestOperation"); + var serviceMethod = InputFactory.BasicServiceMethod("TestOperation", operation); + var inputClient = InputFactory.Client("TestClient", methods: [serviceMethod]); + + var client = ScmCodeModelGenerator.Instance.TypeFactory.CreateClient(inputClient)!; + var methodCollection = new ScmMethodProviderCollection(serviceMethod, client); + var example = new InputOperationExample(exampleKey, null, [], ""); + + return new OperationSample(client, methodCollection, serviceMethod, example, isConvenience, exampleKey); + } + + private static (OperationSample sample, ClientProvider rootClient, ClientProvider subClient) CreateSubClientSample(string exampleKey) + { + var endpointParam = InputFactory.EndpointParameter("endpoint", InputPrimitiveType.Url, isRequired: true); + var parentClient = InputFactory.Client("RootClient", parameters: [endpointParam]); + var subOperation = InputFactory.Operation("DoWork"); + var subServiceMethod = InputFactory.BasicServiceMethod("DoWork", subOperation); + var subClient = InputFactory.Client("SubClient", parent: parentClient, + methods: [subServiceMethod], + initializedBy: InputClientInitializedBy.Parent); + + MockHelpers.LoadMockGenerator(clients: () => [parentClient, subClient]); + + var rootProvider = ScmCodeModelGenerator.Instance.TypeFactory.CreateClient(parentClient)!; + var subProvider = ScmCodeModelGenerator.Instance.TypeFactory.CreateClient(subClient)!; + var methodCollection = new ScmMethodProviderCollection(subServiceMethod, subProvider); + var example = new InputOperationExample(exampleKey, null, [], ""); + + var sample = new OperationSample(subProvider, methodCollection, subServiceMethod, example, false, exampleKey); + return (sample, rootProvider, subProvider); + } + + private static OperationSample CreateSampleWithEndpointExample(string exampleKey, string endpointExample) + { + var endpointParam = InputFactory.EndpointParameter("endpoint", InputPrimitiveType.Url, isRequired: true); + var operation = InputFactory.Operation("TestOperation"); + var serviceMethod = InputFactory.BasicServiceMethod("TestOperation", operation); + var inputClient = InputFactory.Client("TestClient", methods: [serviceMethod]); + + MockHelpers.LoadMockGenerator(); + + var client = ScmCodeModelGenerator.Instance.TypeFactory.CreateClient(inputClient)!; + var methodCollection = new ScmMethodProviderCollection(serviceMethod, client); + var example = new InputOperationExample( + exampleKey, + null, + [new InputParameterExample(endpointParam, InputExampleValue.Value(InputPrimitiveType.Url, endpointExample))], + ""); + + return new OperationSample(client, methodCollection, serviceMethod, example, false, exampleKey); + } + + private static OperationSample CreateSampleWithClientParameterType( + string parameterName, + CSharpType mappedType, + bool isOptional = false, + InputConstant? defaultValue = null) + { + var clientParameter = InputFactory.QueryParameter( + parameterName, + InputPrimitiveType.String, + isRequired: !isOptional, + defaultValue: defaultValue); + var operation = InputFactory.Operation("DoWork"); + var serviceMethod = InputFactory.BasicServiceMethod("DoWork", operation); + var inputClient = InputFactory.Client("TypedClient", parameters: [clientParameter], methods: [serviceMethod]); + + MockHelpers.LoadMockGenerator( + clients: () => [inputClient], + createCSharpTypeCore: _ => mappedType); + + var client = ScmCodeModelGenerator.Instance.TypeFactory.CreateClient(inputClient)!; + var methodCollection = new ScmMethodProviderCollection(serviceMethod, client); + var example = new InputOperationExample("ShortVersion", null, [], ""); + + return new OperationSample(client, methodCollection, serviceMethod, example, false, "ShortVersion"); + } + + // Stub types for credential/LRO tests (matched by type name in TryProcessKnownParameter) + private sealed class TokenCredential { } + private sealed class AzureKeyCredential { } + private sealed class WaitUntil + { + public static WaitUntil Completed { get; } = new WaitUntil(); + } + private sealed class MatchConditions { } + + private static object? GetRawExampleValue(InputExampleValue value) + { + var rawValueProperty = value.GetType().GetProperty("RawValue"); + return rawValueProperty?.GetValue(value); + } + + private static ValueExpression UnwrapCast(ValueExpression expression) + { + while (expression is CastExpression castExpression) + expression = castExpression.Inner; + return expression; + } + + /// Unwrap ScopedApi wrappers to get the underlying expression. + private static ValueExpression Unwrap(ValueExpression expr) + => expr is ScopedApi scoped ? scoped.Original : expr; + + private static InputExampleValue InvokeGetEndpointValue(OperationSample sample, string parameterName) + { + var method = typeof(OperationSample).GetMethod("GetEndpointValue", BindingFlags.Instance | BindingFlags.NonPublic); + Assert.IsNotNull(method); + var value = method!.Invoke(sample, [parameterName]); + Assert.IsNotNull(value); + return (InputExampleValue)value!; + } + } +} diff --git a/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/test/ScmKnownParametersTests.cs b/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/test/ScmKnownParametersTests.cs index 40e7c9e92bd..f058f92aee3 100644 --- a/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/test/ScmKnownParametersTests.cs +++ b/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/test/ScmKnownParametersTests.cs @@ -4,6 +4,7 @@ using System; using Microsoft.TypeSpec.Generator.ClientModel.Primitives; using Microsoft.TypeSpec.Generator.Primitives; +using Microsoft.TypeSpec.Generator.Providers; using NUnit.Framework; using static Microsoft.TypeSpec.Generator.Snippets.Snippet; diff --git a/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.Input/src/InputTypes/InputPrimitiveType.cs b/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.Input/src/InputTypes/InputPrimitiveType.cs index 35843919d7c..286f506de58 100644 --- a/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.Input/src/InputTypes/InputPrimitiveType.cs +++ b/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.Input/src/InputTypes/InputPrimitiveType.cs @@ -39,6 +39,10 @@ public InputPrimitiveType(InputPrimitiveTypeKind kind, string name, string cross public static InputPrimitiveType PlainTime { get; } = new(InputPrimitiveTypeKind.PlainTime, "plainTime", "TypeSpec.plainTime"); public static InputPrimitiveType Any { get; } = new(InputPrimitiveTypeKind.Unknown, "unknown", string.Empty); - public bool IsNumber => Kind is InputPrimitiveTypeKind.Integer or InputPrimitiveTypeKind.Float or InputPrimitiveTypeKind.Int32 or InputPrimitiveTypeKind.Int64 or InputPrimitiveTypeKind.Float32 or InputPrimitiveTypeKind.Float64 or InputPrimitiveTypeKind.Decimal or InputPrimitiveTypeKind.Decimal128 or InputPrimitiveTypeKind.Numeric; + public bool IsNumber => Kind is InputPrimitiveTypeKind.Integer or InputPrimitiveTypeKind.Float or InputPrimitiveTypeKind.Numeric + or InputPrimitiveTypeKind.Int8 or InputPrimitiveTypeKind.Int16 or InputPrimitiveTypeKind.Int32 or InputPrimitiveTypeKind.Int64 or InputPrimitiveTypeKind.SafeInt + or InputPrimitiveTypeKind.UInt8 or InputPrimitiveTypeKind.UInt16 or InputPrimitiveTypeKind.UInt32 or InputPrimitiveTypeKind.UInt64 + or InputPrimitiveTypeKind.Float32 or InputPrimitiveTypeKind.Float64 + or InputPrimitiveTypeKind.Decimal or InputPrimitiveTypeKind.Decimal128; } } diff --git a/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.Input/src/Properties/AssemblyInfo.cs b/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.Input/src/Properties/AssemblyInfo.cs index f3131262a05..53b57a107a3 100644 --- a/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.Input/src/Properties/AssemblyInfo.cs +++ b/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.Input/src/Properties/AssemblyInfo.cs @@ -6,3 +6,5 @@ [assembly: InternalsVisibleTo("Microsoft.TypeSpec.Generator.Input.Tests.Perf, PublicKey=002400000480000094000000060200000024000052534131000400000100010041df4fe80c5af6ff9a410db5a173b0ce24ad68764c623e308b1584a88b1d1d82277f746c1cccba48997e13db3366d5ed676576ffd293293baf42c643f008ba2e8a556e25e529c0407a38506555340749559f5100e6fd78cc935bb6c82d2af303beb0d3c6563400659610759b4ed5cb2e0faf36b17e6842f04cdc544c74e051ba")] [assembly: InternalsVisibleTo("Microsoft.TypeSpec.Generator.Input.Tests, PublicKey=002400000480000094000000060200000024000052534131000400000100010041df4fe80c5af6ff9a410db5a173b0ce24ad68764c623e308b1584a88b1d1d82277f746c1cccba48997e13db3366d5ed676576ffd293293baf42c643f008ba2e8a556e25e529c0407a38506555340749559f5100e6fd78cc935bb6c82d2af303beb0d3c6563400659610759b4ed5cb2e0faf36b17e6842f04cdc544c74e051ba")] [assembly: InternalsVisibleTo("Microsoft.TypeSpec.Generator.Tests.Common, PublicKey=002400000480000094000000060200000024000052534131000400000100010041df4fe80c5af6ff9a410db5a173b0ce24ad68764c623e308b1584a88b1d1d82277f746c1cccba48997e13db3366d5ed676576ffd293293baf42c643f008ba2e8a556e25e529c0407a38506555340749559f5100e6fd78cc935bb6c82d2af303beb0d3c6563400659610759b4ed5cb2e0faf36b17e6842f04cdc544c74e051ba")] +[assembly: InternalsVisibleTo("Microsoft.TypeSpec.Generator, PublicKey=002400000480000094000000060200000024000052534131000400000100010041df4fe80c5af6ff9a410db5a173b0ce24ad68764c623e308b1584a88b1d1d82277f746c1cccba48997e13db3366d5ed676576ffd293293baf42c643f008ba2e8a556e25e529c0407a38506555340749559f5100e6fd78cc935bb6c82d2af303beb0d3c6563400659610759b4ed5cb2e0faf36b17e6842f04cdc544c74e051ba")] +[assembly: InternalsVisibleTo("Microsoft.TypeSpec.Generator.ClientModel, PublicKey=002400000480000094000000060200000024000052534131000400000100010041df4fe80c5af6ff9a410db5a173b0ce24ad68764c623e308b1584a88b1d1d82277f746c1cccba48997e13db3366d5ed676576ffd293293baf42c643f008ba2e8a556e25e529c0407a38506555340749559f5100e6fd78cc935bb6c82d2af303beb0d3c6563400659610759b4ed5cb2e0faf36b17e6842f04cdc544c74e051ba")] diff --git a/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator/src/Samples/ExampleMockValueBuilder.cs b/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator/src/Samples/ExampleMockValueBuilder.cs new file mode 100644 index 00000000000..43dd1328bdc --- /dev/null +++ b/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator/src/Samples/ExampleMockValueBuilder.cs @@ -0,0 +1,234 @@ +// Copyright (c) Microsoft Corporation. All rights reserved. +// Licensed under the MIT License. + +using System.Collections.Generic; +using System.Linq; +using Microsoft.TypeSpec.Generator.Input; + +namespace Microsoft.TypeSpec.Generator.Samples +{ + /// + /// Generates mock instances for operations + /// that don't have examples provided in the spec. + /// + public static class ExampleMockValueBuilder + { + /// + /// Example key for the variant that includes only required parameters. + /// + public const string ShortVersionKey = "ShortVersion"; + + /// + /// Example key for the variant that includes all parameters. + /// + public const string AllParametersKey = "AllParameters"; + + private const string DefaultEndpointValue = ""; + + /// + /// Builds mock operation examples for the given operation. + /// Produces two variants: "ShortVersion" (required params only) and "AllParameters" (all params). + /// If all parameters are required, only "AllParameters" is produced since both would be identical. + /// + public static IReadOnlyList BuildOperationExamples(InputOperation operation) + { + return + [ + BuildOperationExample(operation, ShortVersionKey, useAllParameters: false), + BuildOperationExample(operation, AllParametersKey, useAllParameters: true) + ]; + } + + private static InputOperationExample BuildOperationExample(InputOperation operation, string name, bool useAllParameters) + { + var parameterExamples = new List(operation.Parameters.Count); + foreach (var parameter in operation.Parameters) + { + if (!useAllParameters && !parameter.IsRequired) + { + continue; + } + var parameterExample = BuildParameterExample(parameter, useAllParameters); + parameterExamples.Add(parameterExample); + } + + return new InputOperationExample(name, null, parameterExamples, string.Empty); + } + + /// + /// Builds a mock example value for a single parameter. + /// + internal static InputParameterExample BuildParameterExample(InputParameter parameter, bool useAllParameters) + { + // Constant parameters use their constant value directly + if (parameter.Scope == InputParameterScope.Constant) + { + var value = GetConstantValue(parameter); + return new InputParameterExample(parameter, value); + } + + // Endpoint parameters use a mock URL + if (parameter is InputEndpointParameter { IsEndpoint: true }) + { + var value = InputExampleValue.Value(parameter.Type, DefaultEndpointValue); + return new InputParameterExample(parameter, value); + } + + // Parameters with default values use those + if (parameter.DefaultValue != null) + { + var value = InputExampleValue.Value(parameter.Type, parameter.DefaultValue.Value); + return new InputParameterExample(parameter, value); + } + + // Everything else: generate a mock value based on the type + var exampleValue = BuildExampleValue(parameter.Type, parameter.Name, useAllParameters, new HashSet()); + return new InputParameterExample(parameter, exampleValue); + } + + private static InputExampleValue GetConstantValue(InputParameter parameter) + { + if (parameter.Type is InputLiteralType { Value: not null } literal) + { + return InputExampleValue.Value(parameter.Type, literal.Value); + } + if (parameter.DefaultValue != null) + { + return InputExampleValue.Value(parameter.Type, parameter.DefaultValue.Value); + } + if (parameter.Type is InputUnionType unionType && unionType.VariantTypes[0] is InputLiteralType literalVariant) + { + return InputExampleValue.Value(parameter.Type, literalVariant.Value); + } + if (parameter.Type is InputEnumType enumType && enumType.Values.Count > 0) + { + return InputExampleValue.Value(parameter.Type, enumType.Values[0].Value); + } + return InputExampleValue.Null(parameter.Type); + } + + /// + /// Builds a mock example value for the given input type. + /// This is the main dispatch method that handles all type kinds. + /// + internal static InputExampleValue BuildExampleValue(InputType type, string? hint, bool useAllParameters, HashSet visitedModels) => type switch + { + InputArrayType arrayType => BuildListExampleValue(arrayType, hint, useAllParameters, visitedModels), + InputDictionaryType dictType => BuildDictionaryExampleValue(dictType, hint, useAllParameters, visitedModels), + InputEnumType enumType => BuildEnumExampleValue(enumType), + InputPrimitiveType primitiveType => BuildPrimitiveExampleValue(primitiveType, hint), + InputLiteralType literalType => InputExampleValue.Value(literalType, literalType.Value), + InputModelType modelType => BuildModelExampleValue(modelType, useAllParameters, visitedModels), + InputUnionType unionType => BuildExampleValue(unionType.VariantTypes[0], hint, useAllParameters, visitedModels), + InputNullableType nullableType => BuildExampleValue(nullableType.Type, hint, useAllParameters, visitedModels), + InputDateTimeType dateTimeType => BuildPrimitiveExampleValue(dateTimeType.WireType, hint ?? dateTimeType.Encode.ToString()), + InputDurationType durationType => BuildPrimitiveExampleValue(durationType.WireType, hint ?? durationType.Encode.ToString()), + _ => InputExampleValue.Object(type, new Dictionary()) + }; + + private static InputExampleValue BuildListExampleValue(InputArrayType arrayType, string? hint, bool useAllParameters, HashSet visitedModels) + { + var elementValue = BuildExampleValue(arrayType.ValueType, hint, useAllParameters, visitedModels); + return InputExampleValue.List(arrayType, new[] { elementValue }); + } + + private static InputExampleValue BuildDictionaryExampleValue(InputDictionaryType dictType, string? hint, bool useAllParameters, HashSet visitedModels) + { + var valueExample = BuildExampleValue(dictType.ValueType, hint, useAllParameters, visitedModels); + return InputExampleValue.Object(dictType, new Dictionary + { + ["key"] = valueExample + }); + } + + private static InputExampleValue BuildEnumExampleValue(InputEnumType enumType) + { + var firstValue = enumType.Values.FirstOrDefault(); + return firstValue != null + ? InputExampleValue.Value(enumType, firstValue.Value) + : InputExampleValue.Null(enumType); + } + + private static InputExampleValue BuildPrimitiveExampleValue(InputPrimitiveType primitiveType, string? hint) => primitiveType switch + { + { Kind: InputPrimitiveTypeKind.Boolean } => InputExampleValue.Value(primitiveType, true), + { IsNumber: true } => InputExampleValue.Value(primitiveType, 0), + { Kind: InputPrimitiveTypeKind.Stream } => InputExampleValue.Stream(primitiveType, ""), + _ => BuildStringExampleValue(primitiveType, hint ?? primitiveType.Kind.ToString()) + }; + + private static InputExampleValue BuildStringExampleValue(InputPrimitiveType primitiveType, string? hint) + { + if (primitiveType.Encode == "uuid") + { + return InputExampleValue.Value(primitiveType, ""); + } + + return string.IsNullOrWhiteSpace(hint) + ? InputExampleValue.Value(primitiveType, "") + : InputExampleValue.Value(primitiveType, $"<{hint}>"); + } + + private static InputExampleValue BuildModelExampleValue(InputModelType model, bool useAllParameters, HashSet visitedModels) + { + // Cycle detection: if we've already visited this model, return null to break the loop + if (visitedModels.Contains(model)) + return InputExampleValue.Null(model); + + var properties = new Dictionary(); + var result = InputExampleValue.Object(model, properties); + visitedModels.Add(model); + + // If this model has a discriminator, choose the first derived type + if (model.DiscriminatorProperty != null && model.DerivedModels.Count > 0) + { + var derived = model.DerivedModels.FirstOrDefault(m => !m.IsUnknownDiscriminatorModel); + if (derived != null) + { + model = derived; + } + else + { + return InputExampleValue.Null(model); + } + } + + // Iterate all properties from this model and its base models + foreach (var modelInChain in model.GetSelfAndBaseModels()) + { + foreach (var property in modelInChain.Properties) + { + // Skip read-only properties (they can't be set) + if (property.IsReadOnly) + continue; + + // In ShortVersion, skip optional properties + if (!useAllParameters && !property.IsRequired) + continue; + + // Skip duplicate properties (keep the one from the most-derived type) + if (properties.ContainsKey(property.SerializedName)) + continue; + + InputExampleValue exampleValue; + if (property.IsDiscriminator && model.DiscriminatorValue != null) + { + exampleValue = InputExampleValue.Value(property.Type, model.DiscriminatorValue); + } + else if (property.DefaultValue is { Value: not null } defaultValue) + { + exampleValue = InputExampleValue.Value(property.Type, defaultValue.Value); + } + else + { + exampleValue = BuildExampleValue(property.Type, property.SerializedName, useAllParameters, visitedModels); + } + + properties.Add(property.SerializedName, exampleValue); + } + } + + return result; + } + } +} diff --git a/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator/test/Samples/ExampleMockValueBuilderTests.cs b/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator/test/Samples/ExampleMockValueBuilderTests.cs new file mode 100644 index 00000000000..b86298708e8 --- /dev/null +++ b/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator/test/Samples/ExampleMockValueBuilderTests.cs @@ -0,0 +1,546 @@ +// Copyright (c) Microsoft Corporation. All rights reserved. +// Licensed under the MIT License. + +using System.Collections.Generic; +using System.Linq; +using System.Reflection; +using Microsoft.TypeSpec.Generator.Input; +using Microsoft.TypeSpec.Generator.Samples; +using Microsoft.TypeSpec.Generator.Tests.Common; +using NUnit.Framework; + +namespace Microsoft.TypeSpec.Generator.Tests.Samples +{ + public class ExampleMockValueBuilderTests + { + // ----------------------------------------------------------------------- + // BuildOperationExamples — top-level behavior + // ----------------------------------------------------------------------- + + [Test] + public void BuildOperationExamples_ProducesOneVariant_WhenNoOptionalParameters() + { + var operation = InputFactory.Operation("TestOp", parameters: [ + InputFactory.PathParameter("id", InputPrimitiveType.String, isRequired: true) + ]); + + var examples = ExampleMockValueBuilder.BuildOperationExamples(operation); + + Assert.AreEqual(1, examples.Count); + Assert.AreEqual(ExampleMockValueBuilder.AllParametersKey, examples[0].Name); + } + + [Test] + public void BuildOperationExamples_ProducesTwoVariants_WhenHasOptionalParameters() + { + var operation = InputFactory.Operation("TestOp", parameters: [ + InputFactory.PathParameter("id", InputPrimitiveType.String, isRequired: true), + InputFactory.QueryParameter("filter", InputPrimitiveType.String, isRequired: false) + ]); + + var examples = ExampleMockValueBuilder.BuildOperationExamples(operation); + + Assert.AreEqual(2, examples.Count); + Assert.AreEqual(ExampleMockValueBuilder.ShortVersionKey, examples[0].Name); + Assert.AreEqual(ExampleMockValueBuilder.AllParametersKey, examples[1].Name); + } + + [Test] + public void ShortVersion_SkipsOptionalParameters() + { + var operation = InputFactory.Operation("TestOp", parameters: [ + InputFactory.PathParameter("requiredId", InputPrimitiveType.String, isRequired: true), + InputFactory.QueryParameter("optionalFilter", InputPrimitiveType.String, isRequired: false) + ]); + + var examples = ExampleMockValueBuilder.BuildOperationExamples(operation); + var shortVersion = examples[0]; + var allParams = examples[1]; + + Assert.AreEqual(1, shortVersion.Parameters.Count); + Assert.AreEqual("requiredId", shortVersion.Parameters[0].Parameter.Name); + + Assert.AreEqual(2, allParams.Parameters.Count); + } + + [Test] + public void AllParameters_IncludesOptionalParameters() + { + var operation = InputFactory.Operation("TestOp", parameters: [ + InputFactory.PathParameter("requiredId", InputPrimitiveType.String, isRequired: true), + InputFactory.QueryParameter("optionalFilter", InputPrimitiveType.String, isRequired: false), + InputFactory.HeaderParameter("optionalHeader", InputPrimitiveType.Int32, isRequired: false) + ]); + + var examples = ExampleMockValueBuilder.BuildOperationExamples(operation); + var allParams = examples[1]; + + Assert.AreEqual(3, allParams.Parameters.Count); + } + + [Test] + public void EmptyFilePath_ForMockExamples() + { + var operation = InputFactory.Operation("TestOp", parameters: [ + InputFactory.PathParameter("id", InputPrimitiveType.String, isRequired: true), + InputFactory.QueryParameter("filter", InputPrimitiveType.String, isRequired: false) + ]); + + var examples = ExampleMockValueBuilder.BuildOperationExamples(operation); + + Assert.AreEqual(string.Empty, examples[0].FilePath); + Assert.AreEqual(string.Empty, examples[1].FilePath); + } + + // ----------------------------------------------------------------------- + // Primitive type mock values + // ----------------------------------------------------------------------- + + [Test] + public void PrimitiveType_Boolean() + { + var value = BuildExampleValueForType(InputPrimitiveType.Boolean); + AssertRawValue(value, true); + } + + [Test] + public void PrimitiveType_Int32() + { + var value = BuildExampleValueForType(InputPrimitiveType.Int32); + AssertRawValue(value, 0); + } + + [Test] + public void PrimitiveType_Int64() + { + var value = BuildExampleValueForType(InputPrimitiveType.Int64); + AssertRawValue(value, 0); + } + + [Test] + public void PrimitiveType_Float32() + { + var value = BuildExampleValueForType(InputPrimitiveType.Float32); + AssertRawValue(value, 0); + } + + [Test] + public void PrimitiveType_Float64() + { + var value = BuildExampleValueForType(InputPrimitiveType.Float64); + AssertRawValue(value, 0); + } + + [Test] + public void PrimitiveType_String_WithHint() + { + var value = ExampleMockValueBuilder.BuildExampleValue( + InputPrimitiveType.String, "myParam", false, new HashSet()); + + AssertRawValue(value, ""); + } + + [Test] + public void PrimitiveType_String_WithoutHint() + { + var value = ExampleMockValueBuilder.BuildExampleValue( + InputPrimitiveType.String, null, false, new HashSet()); + + AssertRawValue(value, ""); + } + + [Test] + public void PrimitiveType_Url() + { + var value = BuildExampleValueForType(InputPrimitiveType.Url); + AssertRawValue(value, ""); + } + + [Test] + public void PrimitiveType_PlainDate() + { + var value = BuildExampleValueForType(InputPrimitiveType.PlainDate); + AssertRawValue(value, ""); + } + + [Test] + public void PrimitiveType_PlainTime() + { + var value = BuildExampleValueForType(InputPrimitiveType.PlainTime); + AssertRawValue(value, ""); + } + + [Test] + public void PrimitiveType_Bytes() + { + var value = BuildExampleValueForType(InputPrimitiveType.Base64); + AssertRawValue(value, ""); + } + + [Test] + public void PrimitiveType_Uuid_String() + { + var uuidType = new InputPrimitiveType(InputPrimitiveTypeKind.String, "string", "TypeSpec.string", "uuid"); + var value = ExampleMockValueBuilder.BuildExampleValue( + uuidType, "id", false, new HashSet()); + + AssertRawValue(value, ""); + } + + // ----------------------------------------------------------------------- + // DateTime mock values + // ----------------------------------------------------------------------- + + [Test] + public void DateTime_Rfc3339() + { + var dateTimeType = new InputDateTimeType( + DateTimeKnownEncoding.Rfc3339, "dateTime", "TypeSpec.utcDateTime", InputPrimitiveType.String); + var value = ExampleMockValueBuilder.BuildExampleValue( + dateTimeType, null, false, new HashSet()); + + AssertRawValue(value, ""); + } + + [Test] + public void DateTime_Rfc7231() + { + var dateTimeType = new InputDateTimeType( + DateTimeKnownEncoding.Rfc7231, "dateTime", "TypeSpec.utcDateTime", InputPrimitiveType.String); + var value = ExampleMockValueBuilder.BuildExampleValue( + dateTimeType, null, false, new HashSet()); + + AssertRawValue(value, ""); + } + + [Test] + public void DateTime_UnixTimestamp() + { + var dateTimeType = new InputDateTimeType( + DateTimeKnownEncoding.UnixTimestamp, "dateTime", "TypeSpec.utcDateTime", InputPrimitiveType.Int64); + var value = ExampleMockValueBuilder.BuildExampleValue( + dateTimeType, null, false, new HashSet()); + + AssertRawValue(value, 0); + } + + // ----------------------------------------------------------------------- + // Duration mock values + // ----------------------------------------------------------------------- + + [Test] + public void Duration_Iso8601() + { + var durationType = new InputDurationType( + DurationKnownEncoding.Iso8601, "duration", "TypeSpec.duration", InputPrimitiveType.String, null); + var value = ExampleMockValueBuilder.BuildExampleValue( + durationType, null, false, new HashSet()); + + AssertRawValue(value, ""); + } + + [Test] + public void Duration_Seconds_Int32() + { + var durationType = new InputDurationType( + DurationKnownEncoding.Seconds, "duration", "TypeSpec.duration", InputPrimitiveType.Int32, null); + var value = ExampleMockValueBuilder.BuildExampleValue( + durationType, null, false, new HashSet()); + + AssertRawValue(value, 0); + } + + // ----------------------------------------------------------------------- + // Collection mock values + // ----------------------------------------------------------------------- + + [Test] + public void Array_ProducesSingleElementList() + { + var arrayType = new InputArrayType("list", "TypeSpec.Array", InputPrimitiveType.Int32); + var value = ExampleMockValueBuilder.BuildExampleValue( + arrayType, null, false, new HashSet()); + + Assert.AreEqual(arrayType, value.Type); + AssertIsNotRawNull(value); + } + + [Test] + public void Dictionary_ProducesSingleKeyEntry() + { + var dictType = new InputDictionaryType("dict", InputPrimitiveType.String, InputPrimitiveType.Int32); + var value = ExampleMockValueBuilder.BuildExampleValue( + dictType, null, false, new HashSet()); + + Assert.AreEqual(dictType, value.Type); + AssertIsNotRawNull(value); + } + + // ----------------------------------------------------------------------- + // Enum mock values + // ----------------------------------------------------------------------- + + [Test] + public void Enum_ReturnsFirstEnumValue() + { + var enumType = InputFactory.StringEnum("Color", [("Red", "red"), ("Blue", "blue")]); + var value = ExampleMockValueBuilder.BuildExampleValue( + enumType, null, false, new HashSet()); + + AssertRawValue(value, "red"); + } + + [Test] + public void Enum_Int32_ReturnsFirstValue() + { + var enumType = InputFactory.Int32Enum("Status", [("Active", 1), ("Inactive", 0)]); + var value = ExampleMockValueBuilder.BuildExampleValue( + enumType, null, false, new HashSet()); + + AssertRawValue(value, 1); + } + + // ----------------------------------------------------------------------- + // Literal type + // ----------------------------------------------------------------------- + + [Test] + public void LiteralType_ReturnsLiteralValue() + { + var literalType = InputFactory.Literal.String("fixedValue"); + var value = ExampleMockValueBuilder.BuildExampleValue( + literalType, null, false, new HashSet()); + + AssertRawValue(value, "fixedValue"); + } + + // ----------------------------------------------------------------------- + // Union type + // ----------------------------------------------------------------------- + + [Test] + public void UnionType_ReturnsFirstVariant() + { + var unionType = new InputUnionType("myUnion", [InputPrimitiveType.String, InputPrimitiveType.Int32]); + var value = ExampleMockValueBuilder.BuildExampleValue( + unionType, "field", false, new HashSet()); + + // Should pick the first variant (String) and mock it + AssertRawValue(value, ""); + } + + // ----------------------------------------------------------------------- + // Nullable type + // ----------------------------------------------------------------------- + + [Test] + public void NullableType_UnwrapsAndMocksInner() + { + var nullableType = new InputNullableType(InputPrimitiveType.Int32); + var value = ExampleMockValueBuilder.BuildExampleValue( + nullableType, null, false, new HashSet()); + + AssertRawValue(value, 0); + } + + // ----------------------------------------------------------------------- + // Model mock values + // ----------------------------------------------------------------------- + + [Test] + public void Model_PopulatesRequiredProperties() + { + var model = InputFactory.Model("Widget", properties: [ + InputFactory.Property("name", InputPrimitiveType.String, isRequired: true), + InputFactory.Property("optionalColor", InputPrimitiveType.String, isRequired: false) + ]); + + var value = ExampleMockValueBuilder.BuildExampleValue( + model, null, false, new HashSet()); + + Assert.AreEqual(model, value.Type); + AssertIsNotRawNull(value); + } + + [Test] + public void Model_PopulatesAllProperties_WhenUseAll() + { + var model = InputFactory.Model("Widget", properties: [ + InputFactory.Property("name", InputPrimitiveType.String, isRequired: true), + InputFactory.Property("optionalColor", InputPrimitiveType.String, isRequired: false) + ]); + + var value = ExampleMockValueBuilder.BuildExampleValue( + model, null, true, new HashSet()); + + Assert.AreEqual(model, value.Type); + AssertIsNotRawNull(value); + } + + [Test] + public void Model_SkipsReadOnlyProperties() + { + var model = InputFactory.Model("Widget", properties: [ + InputFactory.Property("name", InputPrimitiveType.String, isRequired: true), + InputFactory.Property("id", InputPrimitiveType.String, isRequired: true, isReadOnly: true) + ]); + + var value = ExampleMockValueBuilder.BuildExampleValue( + model, null, true, new HashSet()); + + Assert.AreEqual(model, value.Type); + AssertIsNotRawNull(value); + } + + [Test] + public void Model_IncludesBaseModelProperties() + { + var baseModel = InputFactory.Model("BaseWidget", properties: [ + InputFactory.Property("baseField", InputPrimitiveType.String, isRequired: true) + ]); + var derivedModel = InputFactory.Model("DerivedWidget", baseModel: baseModel, properties: [ + InputFactory.Property("derivedField", InputPrimitiveType.Int32, isRequired: true) + ]); + + var value = ExampleMockValueBuilder.BuildExampleValue( + derivedModel, null, true, new HashSet()); + + AssertIsNotRawNull(value); + } + + [Test] + public void Model_CircularReference_ReturnsNull() + { + var selfRefModel = InputFactory.Model("Node", properties: [ + InputFactory.Property("name", InputPrimitiveType.String, isRequired: true) + ]); + + // Pre-add to visited set to simulate circular reference + var visited = new HashSet { selfRefModel }; + var value = ExampleMockValueBuilder.BuildExampleValue( + selfRefModel, null, true, visited); + + // Circular reference should produce a null value + Assert.IsNotNull(value); + Assert.AreEqual(selfRefModel, value.Type); + } + + [Test] + public void Model_WithDiscriminator_ChoosesDerivedType() + { + var baseModel = InputFactory.Model("Pet", + properties: [ + InputFactory.Property("kind", InputPrimitiveType.String, isRequired: true, isDiscriminator: true) + ], + discriminatedModels: new Dictionary()); + + var catModel = InputFactory.Model("Cat", + discriminatedKind: "cat", + baseModel: baseModel, + properties: [ + InputFactory.Property("meow", InputPrimitiveType.Boolean, isRequired: true) + ]); + + var value = ExampleMockValueBuilder.BuildExampleValue( + baseModel, null, true, new HashSet()); + + // Should produce a non-null object value (derived type selected) + Assert.IsNotNull(value); + AssertIsNotRawNull(value); + } + + // ----------------------------------------------------------------------- + // Parameter handling + // ----------------------------------------------------------------------- + + [Test] + public void Parameter_Endpoint_UsesMockUrl() + { + var endpointParam = InputFactory.EndpointParameter("endpoint", InputPrimitiveType.Url, isRequired: true); + var operation = InputFactory.Operation("TestOp", parameters: [endpointParam]); + + var examples = ExampleMockValueBuilder.BuildOperationExamples(operation); + var paramExample = examples[0].Parameters[0]; + + AssertRawValue(paramExample.ExampleValue, ""); + } + + [Test] + public void Parameter_Constant_UsesConstantValue() + { + var constParam = InputFactory.HeaderParameter("apiVersion", InputFactory.Literal.String("2024-01-01"), + isRequired: true, scope: InputParameterScope.Constant, + defaultValue: InputFactory.Constant.String("2024-01-01")); + + var operation = InputFactory.Operation("TestOp", parameters: [constParam]); + + var examples = ExampleMockValueBuilder.BuildOperationExamples(operation); + var paramExample = examples[0].Parameters[0]; + + AssertRawValue(paramExample.ExampleValue, "2024-01-01"); + } + + [Test] + public void Parameter_WithDefaultValue_UsesDefault() + { + var paramWithDefault = InputFactory.QueryParameter("count", InputPrimitiveType.Int32, + isRequired: true, defaultValue: new InputConstant(10, InputPrimitiveType.Int32)); + + var operation = InputFactory.Operation("TestOp", parameters: [paramWithDefault]); + + var examples = ExampleMockValueBuilder.BuildOperationExamples(operation); + var paramExample = examples[0].Parameters[0]; + + AssertRawValue(paramExample.ExampleValue, 10); + } + + [Test] + public void OperationWithNoParameters_ProducesEmptyExamples() + { + var operation = InputFactory.Operation("EmptyOp", parameters: []); + + var examples = ExampleMockValueBuilder.BuildOperationExamples(operation); + + Assert.AreEqual(2, examples.Count); + Assert.AreEqual(0, examples[0].Parameters.Count); + Assert.AreEqual(0, examples[1].Parameters.Count); + } + + // ----------------------------------------------------------------------- + // Helpers + // ----------------------------------------------------------------------- + + private static InputExampleValue BuildExampleValueForType(InputType type) + { + return ExampleMockValueBuilder.BuildExampleValue(type, null, false, new HashSet()); + } + + /// + /// Asserts that the value is a raw example value matching the expected object. + /// Since InputExampleRawValue is internal, we use reflection to access RawValue. + /// + private static void AssertRawValue(InputExampleValue value, object expected) + { + var expectedValue = InputExampleValue.Value(value.Type, expected); + Assert.AreEqual(expectedValue.GetType(), value.GetType(), + $"Expected raw value type but got {value.GetType().Name}"); + var rawValueProp = value.GetType().GetProperty("RawValue"); + Assert.IsNotNull(rawValueProp, "Expected value to have RawValue property"); + var actualRaw = rawValueProp!.GetValue(value); + Assert.AreEqual(expected, actualRaw); + } + + /// + /// Asserts the value is not a null raw value — it should be a composite type (list, object). + /// + private static void AssertIsNotRawNull(InputExampleValue value) + { + var rawValueProp = value.GetType().GetProperty("RawValue"); + if (rawValueProp != null) + { + var rawVal = rawValueProp.GetValue(value); + Assert.IsNotNull(rawVal, "Expected a non-null value but got null (possible circular reference issue)"); + } + } + } +} diff --git a/packages/http-client-csharp/generator/TestProjects/Local/Sample-TypeSpec/src/Generated/SampleTypeSpecClient.cs b/packages/http-client-csharp/generator/TestProjects/Local/Sample-TypeSpec/src/Generated/SampleTypeSpecClient.cs index d9eea363b0a..659c42158d9 100644 --- a/packages/http-client-csharp/generator/TestProjects/Local/Sample-TypeSpec/src/Generated/SampleTypeSpecClient.cs +++ b/packages/http-client-csharp/generator/TestProjects/Local/Sample-TypeSpec/src/Generated/SampleTypeSpecClient.cs @@ -1082,19 +1082,19 @@ public virtual async Task GetUnknownValueAsync(RequestOptions opti /// get extensible enum. /// The cancellation token that can be used to cancel the operation. /// Service returned a non-success status code. - public virtual ClientResult GetUnknownValue(CancellationToken cancellationToken = default) + public virtual ClientResult GetUnknownValue(CancellationToken cancellationToken = default) { ClientResult result = GetUnknownValue(cancellationToken.ToRequestOptions()); - return ClientResult.FromValue(result.GetRawResponse().Content.ToString(), result.GetRawResponse()); + return ClientResult.FromValue(new DaysOfWeekExtensibleEnum(result.GetRawResponse().Content.ToObjectFromJson()), result.GetRawResponse()); } /// get extensible enum. /// The cancellation token that can be used to cancel the operation. /// Service returned a non-success status code. - public virtual async Task> GetUnknownValueAsync(CancellationToken cancellationToken = default) + public virtual async Task> GetUnknownValueAsync(CancellationToken cancellationToken = default) { ClientResult result = await GetUnknownValueAsync(cancellationToken.ToRequestOptions()).ConfigureAwait(false); - return ClientResult.FromValue(result.GetRawResponse().Content.ToString(), result.GetRawResponse()); + return ClientResult.FromValue(new DaysOfWeekExtensibleEnum(result.GetRawResponse().Content.ToObjectFromJson()), result.GetRawResponse()); } /// diff --git a/packages/http-client-csharp/generator/TestProjects/Local/Sample-TypeSpec/tests/Generated/Samples/Samples_SampleTypeSpecClient.cs b/packages/http-client-csharp/generator/TestProjects/Local/Sample-TypeSpec/tests/Generated/Samples/Samples_SampleTypeSpecClient.cs new file mode 100644 index 00000000000..46c173990e3 --- /dev/null +++ b/packages/http-client-csharp/generator/TestProjects/Local/Sample-TypeSpec/tests/Generated/Samples/Samples_SampleTypeSpecClient.cs @@ -0,0 +1,5704 @@ +// Copyright (c) Microsoft. All rights reserved. +// Licensed under the MIT License. + +// + +#nullable disable + +using System; +using System.ClientModel; +using System.ClientModel.Primitives; +using System.Collections.Generic; +using System.Text.Json; +using System.Threading.Tasks; +using System.Xml; +using SampleTypeSpec.Models.Custom; + +namespace SampleTypeSpec +{ + /// + public partial class Samples_SampleTypeSpecClient + { + /// This sample shows how to call SayHi and parse the result. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public void Example_SampleTypeSpec_SayHi_ShortVersion() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + ClientResult response = client.SayHi("", "", null, null); + + JsonElement result = JsonDocument.Parse(response.GetRawResponse().ContentStream).RootElement; + Console.WriteLine(result.GetProperty("name").ToString()); + Console.WriteLine(result.GetProperty("requiredUnion").ToString()); + Console.WriteLine(result.GetProperty("requiredLiteralString").ToString()); + Console.WriteLine(result.GetProperty("requiredNullableString").ToString()); + Console.WriteLine(result.GetProperty("requiredLiteralInt").ToString()); + Console.WriteLine(result.GetProperty("requiredLiteralFloat").ToString()); + Console.WriteLine(result.GetProperty("requiredLiteralBool").ToString()); + Console.WriteLine(result.GetProperty("requiredNullableLiteralString").ToString()); + Console.WriteLine(result.GetProperty("requiredBadDescription").ToString()); + Console.WriteLine(result.GetProperty("requiredNullableList").ToString()); + Console.WriteLine(result.GetProperty("propertyWithSpecialDocs").ToString()); + } + + /// This sample shows how to call SayHiAsync and parse the result. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public async Task Example_SampleTypeSpec_SayHi_ShortVersion_Async() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + ClientResult response = await client.SayHiAsync("", "", null, null).ConfigureAwait(false); + + JsonElement result = JsonDocument.Parse(response.GetRawResponse().ContentStream).RootElement; + Console.WriteLine(result.GetProperty("name").ToString()); + Console.WriteLine(result.GetProperty("requiredUnion").ToString()); + Console.WriteLine(result.GetProperty("requiredLiteralString").ToString()); + Console.WriteLine(result.GetProperty("requiredNullableString").ToString()); + Console.WriteLine(result.GetProperty("requiredLiteralInt").ToString()); + Console.WriteLine(result.GetProperty("requiredLiteralFloat").ToString()); + Console.WriteLine(result.GetProperty("requiredLiteralBool").ToString()); + Console.WriteLine(result.GetProperty("requiredNullableLiteralString").ToString()); + Console.WriteLine(result.GetProperty("requiredBadDescription").ToString()); + Console.WriteLine(result.GetProperty("requiredNullableList").ToString()); + Console.WriteLine(result.GetProperty("propertyWithSpecialDocs").ToString()); + } + + /// This sample shows how to call SayHi. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public void Example_SampleTypeSpec_SayHi_ShortVersion_Convenience() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + ClientResult response = client.SayHi("", ""); + + } + + /// This sample shows how to call SayHiAsync. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public async Task Example_SampleTypeSpec_SayHi_ShortVersion_Convenience_Async() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + ClientResult response = await client.SayHiAsync("", "").ConfigureAwait(false); + + } + + /// This sample shows how to call SayHi with all parameters and parse the result. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public void Example_SampleTypeSpec_SayHi_AllParameters() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + ClientResult response = client.SayHi("", "", "", null); + + JsonElement result = JsonDocument.Parse(response.GetRawResponse().ContentStream).RootElement; + Console.WriteLine(result.GetProperty("name").ToString()); + Console.WriteLine(result.GetProperty("requiredUnion").ToString()); + Console.WriteLine(result.GetProperty("requiredLiteralString").ToString()); + Console.WriteLine(result.GetProperty("requiredNullableString").ToString()); + Console.WriteLine(result.GetProperty("optionalNullableString").ToString()); + Console.WriteLine(result.GetProperty("requiredLiteralInt").ToString()); + Console.WriteLine(result.GetProperty("requiredLiteralFloat").ToString()); + Console.WriteLine(result.GetProperty("requiredLiteralBool").ToString()); + Console.WriteLine(result.GetProperty("optionalLiteralString").ToString()); + Console.WriteLine(result.GetProperty("requiredNullableLiteralString").ToString()); + Console.WriteLine(result.GetProperty("optionalLiteralInt").ToString()); + Console.WriteLine(result.GetProperty("optionalLiteralFloat").ToString()); + Console.WriteLine(result.GetProperty("optionalLiteralBool").ToString()); + Console.WriteLine(result.GetProperty("requiredBadDescription").ToString()); + Console.WriteLine(result.GetProperty("optionalNullableList").ToString()); + Console.WriteLine(result.GetProperty("requiredNullableList").ToString()); + Console.WriteLine(result.GetProperty("propertyWithSpecialDocs").ToString()); + } + + /// This sample shows how to call SayHiAsync with all parameters and parse the result. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public async Task Example_SampleTypeSpec_SayHi_AllParameters_Async() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + ClientResult response = await client.SayHiAsync("", "", "", null).ConfigureAwait(false); + + JsonElement result = JsonDocument.Parse(response.GetRawResponse().ContentStream).RootElement; + Console.WriteLine(result.GetProperty("name").ToString()); + Console.WriteLine(result.GetProperty("requiredUnion").ToString()); + Console.WriteLine(result.GetProperty("requiredLiteralString").ToString()); + Console.WriteLine(result.GetProperty("requiredNullableString").ToString()); + Console.WriteLine(result.GetProperty("optionalNullableString").ToString()); + Console.WriteLine(result.GetProperty("requiredLiteralInt").ToString()); + Console.WriteLine(result.GetProperty("requiredLiteralFloat").ToString()); + Console.WriteLine(result.GetProperty("requiredLiteralBool").ToString()); + Console.WriteLine(result.GetProperty("optionalLiteralString").ToString()); + Console.WriteLine(result.GetProperty("requiredNullableLiteralString").ToString()); + Console.WriteLine(result.GetProperty("optionalLiteralInt").ToString()); + Console.WriteLine(result.GetProperty("optionalLiteralFloat").ToString()); + Console.WriteLine(result.GetProperty("optionalLiteralBool").ToString()); + Console.WriteLine(result.GetProperty("requiredBadDescription").ToString()); + Console.WriteLine(result.GetProperty("optionalNullableList").ToString()); + Console.WriteLine(result.GetProperty("requiredNullableList").ToString()); + Console.WriteLine(result.GetProperty("propertyWithSpecialDocs").ToString()); + } + + /// This sample shows how to call SayHi with all parameters. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public void Example_SampleTypeSpec_SayHi_AllParameters_Convenience() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + ClientResult response = client.SayHi("", "", ""); + + } + + /// This sample shows how to call SayHiAsync with all parameters. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public async Task Example_SampleTypeSpec_SayHi_AllParameters_Convenience_Async() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + ClientResult response = await client.SayHiAsync("", "", "").ConfigureAwait(false); + + } + + /// This sample shows how to call HelloAgain and parse the result. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public void Example_SampleTypeSpec_HelloAgain_ShortVersion() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + using BinaryContent content = BinaryContent.Create(BinaryData.FromObjectAsJson(new + { + requiredString = "", + requiredInt = 0, + requiredCollection = new object[] { "1" }, + requiredDictionary = new + { + key = "1" + }, + requiredModel = new + { + name = "", + requiredUnion = "", + requiredLiteralString = "accept", + requiredNullableString = "", + requiredLiteralInt = 123, + requiredLiteralFloat = 1.23F, + requiredLiteralBool = false, + requiredNullableLiteralString = "someValue", + requiredBadDescription = "", + requiredNullableList = new object[] { 0 }, + propertyWithSpecialDocs = "" + }, + requiredUnknown = "", + requiredRecordUnknown = new + { + key = "" + }, + modelWithRequiredNullable = new + { + requiredNullablePrimitive = 0, + requiredExtensibleEnum = "1", + requiredFixedEnum = "1" + }, + requiredBytes = "" + })); + ClientResult response = client.HelloAgain("", "", content); + + JsonElement result = JsonDocument.Parse(response.GetRawResponse().ContentStream).RootElement; + Console.WriteLine(result.GetProperty("requiredString").ToString()); + Console.WriteLine(result.GetProperty("requiredInt").ToString()); + Console.WriteLine(result.GetProperty("requiredCollection")[0].ToString()); + Console.WriteLine(result.GetProperty("requiredDictionary").ToString()); + Console.WriteLine(result.GetProperty("requiredModel").GetProperty("name").ToString()); + Console.WriteLine(result.GetProperty("requiredModel").GetProperty("requiredUnion").ToString()); + Console.WriteLine(result.GetProperty("requiredModel").GetProperty("requiredLiteralString").ToString()); + Console.WriteLine(result.GetProperty("requiredModel").GetProperty("requiredNullableString").ToString()); + Console.WriteLine(result.GetProperty("requiredModel").GetProperty("requiredLiteralInt").ToString()); + Console.WriteLine(result.GetProperty("requiredModel").GetProperty("requiredLiteralFloat").ToString()); + Console.WriteLine(result.GetProperty("requiredModel").GetProperty("requiredLiteralBool").ToString()); + Console.WriteLine(result.GetProperty("requiredModel").GetProperty("requiredNullableLiteralString").ToString()); + Console.WriteLine(result.GetProperty("requiredModel").GetProperty("requiredBadDescription").ToString()); + Console.WriteLine(result.GetProperty("requiredModel").GetProperty("requiredNullableList").ToString()); + Console.WriteLine(result.GetProperty("requiredModel").GetProperty("propertyWithSpecialDocs").ToString()); + Console.WriteLine(result.GetProperty("requiredUnknown").ToString()); + Console.WriteLine(result.GetProperty("requiredRecordUnknown").ToString()); + Console.WriteLine(result.GetProperty("readOnlyRequiredRecordUnknown").ToString()); + Console.WriteLine(result.GetProperty("modelWithRequiredNullable").GetProperty("requiredNullablePrimitive").ToString()); + Console.WriteLine(result.GetProperty("modelWithRequiredNullable").GetProperty("requiredExtensibleEnum").ToString()); + Console.WriteLine(result.GetProperty("modelWithRequiredNullable").GetProperty("requiredFixedEnum").ToString()); + Console.WriteLine(result.GetProperty("requiredBytes").ToString()); + } + + /// This sample shows how to call HelloAgainAsync and parse the result. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public async Task Example_SampleTypeSpec_HelloAgain_ShortVersion_Async() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + using BinaryContent content = BinaryContent.Create(BinaryData.FromObjectAsJson(new + { + requiredString = "", + requiredInt = 0, + requiredCollection = new object[] { "1" }, + requiredDictionary = new + { + key = "1" + }, + requiredModel = new + { + name = "", + requiredUnion = "", + requiredLiteralString = "accept", + requiredNullableString = "", + requiredLiteralInt = 123, + requiredLiteralFloat = 1.23F, + requiredLiteralBool = false, + requiredNullableLiteralString = "someValue", + requiredBadDescription = "", + requiredNullableList = new object[] { 0 }, + propertyWithSpecialDocs = "" + }, + requiredUnknown = "", + requiredRecordUnknown = new + { + key = "" + }, + modelWithRequiredNullable = new + { + requiredNullablePrimitive = 0, + requiredExtensibleEnum = "1", + requiredFixedEnum = "1" + }, + requiredBytes = "" + })); + ClientResult response = await client.HelloAgainAsync("", "", content).ConfigureAwait(false); + + JsonElement result = JsonDocument.Parse(response.GetRawResponse().ContentStream).RootElement; + Console.WriteLine(result.GetProperty("requiredString").ToString()); + Console.WriteLine(result.GetProperty("requiredInt").ToString()); + Console.WriteLine(result.GetProperty("requiredCollection")[0].ToString()); + Console.WriteLine(result.GetProperty("requiredDictionary").ToString()); + Console.WriteLine(result.GetProperty("requiredModel").GetProperty("name").ToString()); + Console.WriteLine(result.GetProperty("requiredModel").GetProperty("requiredUnion").ToString()); + Console.WriteLine(result.GetProperty("requiredModel").GetProperty("requiredLiteralString").ToString()); + Console.WriteLine(result.GetProperty("requiredModel").GetProperty("requiredNullableString").ToString()); + Console.WriteLine(result.GetProperty("requiredModel").GetProperty("requiredLiteralInt").ToString()); + Console.WriteLine(result.GetProperty("requiredModel").GetProperty("requiredLiteralFloat").ToString()); + Console.WriteLine(result.GetProperty("requiredModel").GetProperty("requiredLiteralBool").ToString()); + Console.WriteLine(result.GetProperty("requiredModel").GetProperty("requiredNullableLiteralString").ToString()); + Console.WriteLine(result.GetProperty("requiredModel").GetProperty("requiredBadDescription").ToString()); + Console.WriteLine(result.GetProperty("requiredModel").GetProperty("requiredNullableList").ToString()); + Console.WriteLine(result.GetProperty("requiredModel").GetProperty("propertyWithSpecialDocs").ToString()); + Console.WriteLine(result.GetProperty("requiredUnknown").ToString()); + Console.WriteLine(result.GetProperty("requiredRecordUnknown").ToString()); + Console.WriteLine(result.GetProperty("readOnlyRequiredRecordUnknown").ToString()); + Console.WriteLine(result.GetProperty("modelWithRequiredNullable").GetProperty("requiredNullablePrimitive").ToString()); + Console.WriteLine(result.GetProperty("modelWithRequiredNullable").GetProperty("requiredExtensibleEnum").ToString()); + Console.WriteLine(result.GetProperty("modelWithRequiredNullable").GetProperty("requiredFixedEnum").ToString()); + Console.WriteLine(result.GetProperty("requiredBytes").ToString()); + } + + /// This sample shows how to call HelloAgain. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public void Example_SampleTypeSpec_HelloAgain_ShortVersion_Convenience() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + RoundTripModel action = new RoundTripModel( + "", + 0, + new StringFixedEnum[] { StringFixedEnum.One }, + new Dictionary + { + { "key", StringExtensibleEnum.One } + }, + new Thing( + "", + BinaryData.FromObjectAsJson(""), + "", + ThingRequiredNullableLiteralString1.SomeValue, + "", + new int[] { 0 }, + ""), + BinaryData.FromObjectAsJson(""), + new Dictionary + { + { "key", BinaryData.FromObjectAsJson("") } + }, + new ModelWithRequiredNullableProperties(0, StringExtensibleEnum.One, StringFixedEnum.One), + BinaryData.FromObjectAsJson("")); + ClientResult response = client.HelloAgain("", "", action); + + } + + /// This sample shows how to call HelloAgainAsync. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public async Task Example_SampleTypeSpec_HelloAgain_ShortVersion_Convenience_Async() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + RoundTripModel action = new RoundTripModel( + "", + 0, + new StringFixedEnum[] { StringFixedEnum.One }, + new Dictionary + { + { "key", StringExtensibleEnum.One } + }, + new Thing( + "", + BinaryData.FromObjectAsJson(""), + "", + ThingRequiredNullableLiteralString1.SomeValue, + "", + new int[] { 0 }, + ""), + BinaryData.FromObjectAsJson(""), + new Dictionary + { + { "key", BinaryData.FromObjectAsJson("") } + }, + new ModelWithRequiredNullableProperties(0, StringExtensibleEnum.One, StringFixedEnum.One), + BinaryData.FromObjectAsJson("")); + ClientResult response = await client.HelloAgainAsync("", "", action).ConfigureAwait(false); + + } + + /// This sample shows how to call HelloAgain with all parameters and request content and parse the result. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public void Example_SampleTypeSpec_HelloAgain_AllParameters() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + using BinaryContent content = BinaryContent.Create(BinaryData.FromObjectAsJson(new + { + requiredString = "", + requiredInt = 0, + requiredCollection = new object[] { "1" }, + requiredDictionary = new + { + key = "1" + }, + requiredModel = new + { + name = "", + requiredUnion = "", + requiredLiteralString = "accept", + requiredNullableString = "", + optionalNullableString = "", + requiredLiteralInt = 123, + requiredLiteralFloat = 1.23F, + requiredLiteralBool = false, + optionalLiteralString = "reject", + requiredNullableLiteralString = "someValue", + optionalLiteralInt = 456, + optionalLiteralFloat = 4.56F, + optionalLiteralBool = true, + requiredBadDescription = "", + optionalNullableList = new object[] { 0 }, + requiredNullableList = new object[] { 0 }, + propertyWithSpecialDocs = "" + }, + intExtensibleEnum = 1, + intExtensibleEnumCollection = new object[] { 1 }, + floatExtensibleEnum = 1.1F, + floatExtensibleEnumWithIntValue = 1F, + floatExtensibleEnumCollection = new object[] { 1.1F }, + floatFixedEnum = 1.1F, + floatFixedEnumWithIntValue = 1, + floatFixedEnumCollection = new object[] { 1.1F }, + intFixedEnum = 1, + intFixedEnumCollection = new object[] { 1 }, + stringFixedEnum = "1", + requiredUnknown = "", + optionalUnknown = "", + requiredRecordUnknown = new + { + key = "" + }, + optionalRecordUnknown = new + { + key = "" + }, + modelWithRequiredNullable = new + { + requiredNullablePrimitive = 0, + requiredExtensibleEnum = "1", + requiredFixedEnum = "1" + }, + requiredBytes = "" + })); + ClientResult response = client.HelloAgain("", "", content); + + JsonElement result = JsonDocument.Parse(response.GetRawResponse().ContentStream).RootElement; + Console.WriteLine(result.GetProperty("requiredString").ToString()); + Console.WriteLine(result.GetProperty("requiredInt").ToString()); + Console.WriteLine(result.GetProperty("requiredCollection")[0].ToString()); + Console.WriteLine(result.GetProperty("requiredDictionary").ToString()); + Console.WriteLine(result.GetProperty("requiredModel").GetProperty("name").ToString()); + Console.WriteLine(result.GetProperty("requiredModel").GetProperty("requiredUnion").ToString()); + Console.WriteLine(result.GetProperty("requiredModel").GetProperty("requiredLiteralString").ToString()); + Console.WriteLine(result.GetProperty("requiredModel").GetProperty("requiredNullableString").ToString()); + Console.WriteLine(result.GetProperty("requiredModel").GetProperty("optionalNullableString").ToString()); + Console.WriteLine(result.GetProperty("requiredModel").GetProperty("requiredLiteralInt").ToString()); + Console.WriteLine(result.GetProperty("requiredModel").GetProperty("requiredLiteralFloat").ToString()); + Console.WriteLine(result.GetProperty("requiredModel").GetProperty("requiredLiteralBool").ToString()); + Console.WriteLine(result.GetProperty("requiredModel").GetProperty("optionalLiteralString").ToString()); + Console.WriteLine(result.GetProperty("requiredModel").GetProperty("requiredNullableLiteralString").ToString()); + Console.WriteLine(result.GetProperty("requiredModel").GetProperty("optionalLiteralInt").ToString()); + Console.WriteLine(result.GetProperty("requiredModel").GetProperty("optionalLiteralFloat").ToString()); + Console.WriteLine(result.GetProperty("requiredModel").GetProperty("optionalLiteralBool").ToString()); + Console.WriteLine(result.GetProperty("requiredModel").GetProperty("requiredBadDescription").ToString()); + Console.WriteLine(result.GetProperty("requiredModel").GetProperty("optionalNullableList").ToString()); + Console.WriteLine(result.GetProperty("requiredModel").GetProperty("requiredNullableList").ToString()); + Console.WriteLine(result.GetProperty("requiredModel").GetProperty("propertyWithSpecialDocs").ToString()); + Console.WriteLine(result.GetProperty("intExtensibleEnum").ToString()); + Console.WriteLine(result.GetProperty("intExtensibleEnumCollection")[0].ToString()); + Console.WriteLine(result.GetProperty("floatExtensibleEnum").ToString()); + Console.WriteLine(result.GetProperty("floatExtensibleEnumWithIntValue").ToString()); + Console.WriteLine(result.GetProperty("floatExtensibleEnumCollection")[0].ToString()); + Console.WriteLine(result.GetProperty("floatFixedEnum").ToString()); + Console.WriteLine(result.GetProperty("floatFixedEnumWithIntValue").ToString()); + Console.WriteLine(result.GetProperty("floatFixedEnumCollection")[0].ToString()); + Console.WriteLine(result.GetProperty("intFixedEnum").ToString()); + Console.WriteLine(result.GetProperty("intFixedEnumCollection")[0].ToString()); + Console.WriteLine(result.GetProperty("stringFixedEnum").ToString()); + Console.WriteLine(result.GetProperty("requiredUnknown").ToString()); + Console.WriteLine(result.GetProperty("optionalUnknown").ToString()); + Console.WriteLine(result.GetProperty("requiredRecordUnknown").ToString()); + Console.WriteLine(result.GetProperty("optionalRecordUnknown").ToString()); + Console.WriteLine(result.GetProperty("readOnlyRequiredRecordUnknown").ToString()); + Console.WriteLine(result.GetProperty("readOnlyOptionalRecordUnknown").ToString()); + Console.WriteLine(result.GetProperty("modelWithRequiredNullable").GetProperty("requiredNullablePrimitive").ToString()); + Console.WriteLine(result.GetProperty("modelWithRequiredNullable").GetProperty("requiredExtensibleEnum").ToString()); + Console.WriteLine(result.GetProperty("modelWithRequiredNullable").GetProperty("requiredFixedEnum").ToString()); + Console.WriteLine(result.GetProperty("requiredBytes").ToString()); + } + + /// This sample shows how to call HelloAgainAsync with all parameters and request content and parse the result. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public async Task Example_SampleTypeSpec_HelloAgain_AllParameters_Async() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + using BinaryContent content = BinaryContent.Create(BinaryData.FromObjectAsJson(new + { + requiredString = "", + requiredInt = 0, + requiredCollection = new object[] { "1" }, + requiredDictionary = new + { + key = "1" + }, + requiredModel = new + { + name = "", + requiredUnion = "", + requiredLiteralString = "accept", + requiredNullableString = "", + optionalNullableString = "", + requiredLiteralInt = 123, + requiredLiteralFloat = 1.23F, + requiredLiteralBool = false, + optionalLiteralString = "reject", + requiredNullableLiteralString = "someValue", + optionalLiteralInt = 456, + optionalLiteralFloat = 4.56F, + optionalLiteralBool = true, + requiredBadDescription = "", + optionalNullableList = new object[] { 0 }, + requiredNullableList = new object[] { 0 }, + propertyWithSpecialDocs = "" + }, + intExtensibleEnum = 1, + intExtensibleEnumCollection = new object[] { 1 }, + floatExtensibleEnum = 1.1F, + floatExtensibleEnumWithIntValue = 1F, + floatExtensibleEnumCollection = new object[] { 1.1F }, + floatFixedEnum = 1.1F, + floatFixedEnumWithIntValue = 1, + floatFixedEnumCollection = new object[] { 1.1F }, + intFixedEnum = 1, + intFixedEnumCollection = new object[] { 1 }, + stringFixedEnum = "1", + requiredUnknown = "", + optionalUnknown = "", + requiredRecordUnknown = new + { + key = "" + }, + optionalRecordUnknown = new + { + key = "" + }, + modelWithRequiredNullable = new + { + requiredNullablePrimitive = 0, + requiredExtensibleEnum = "1", + requiredFixedEnum = "1" + }, + requiredBytes = "" + })); + ClientResult response = await client.HelloAgainAsync("", "", content).ConfigureAwait(false); + + JsonElement result = JsonDocument.Parse(response.GetRawResponse().ContentStream).RootElement; + Console.WriteLine(result.GetProperty("requiredString").ToString()); + Console.WriteLine(result.GetProperty("requiredInt").ToString()); + Console.WriteLine(result.GetProperty("requiredCollection")[0].ToString()); + Console.WriteLine(result.GetProperty("requiredDictionary").ToString()); + Console.WriteLine(result.GetProperty("requiredModel").GetProperty("name").ToString()); + Console.WriteLine(result.GetProperty("requiredModel").GetProperty("requiredUnion").ToString()); + Console.WriteLine(result.GetProperty("requiredModel").GetProperty("requiredLiteralString").ToString()); + Console.WriteLine(result.GetProperty("requiredModel").GetProperty("requiredNullableString").ToString()); + Console.WriteLine(result.GetProperty("requiredModel").GetProperty("optionalNullableString").ToString()); + Console.WriteLine(result.GetProperty("requiredModel").GetProperty("requiredLiteralInt").ToString()); + Console.WriteLine(result.GetProperty("requiredModel").GetProperty("requiredLiteralFloat").ToString()); + Console.WriteLine(result.GetProperty("requiredModel").GetProperty("requiredLiteralBool").ToString()); + Console.WriteLine(result.GetProperty("requiredModel").GetProperty("optionalLiteralString").ToString()); + Console.WriteLine(result.GetProperty("requiredModel").GetProperty("requiredNullableLiteralString").ToString()); + Console.WriteLine(result.GetProperty("requiredModel").GetProperty("optionalLiteralInt").ToString()); + Console.WriteLine(result.GetProperty("requiredModel").GetProperty("optionalLiteralFloat").ToString()); + Console.WriteLine(result.GetProperty("requiredModel").GetProperty("optionalLiteralBool").ToString()); + Console.WriteLine(result.GetProperty("requiredModel").GetProperty("requiredBadDescription").ToString()); + Console.WriteLine(result.GetProperty("requiredModel").GetProperty("optionalNullableList").ToString()); + Console.WriteLine(result.GetProperty("requiredModel").GetProperty("requiredNullableList").ToString()); + Console.WriteLine(result.GetProperty("requiredModel").GetProperty("propertyWithSpecialDocs").ToString()); + Console.WriteLine(result.GetProperty("intExtensibleEnum").ToString()); + Console.WriteLine(result.GetProperty("intExtensibleEnumCollection")[0].ToString()); + Console.WriteLine(result.GetProperty("floatExtensibleEnum").ToString()); + Console.WriteLine(result.GetProperty("floatExtensibleEnumWithIntValue").ToString()); + Console.WriteLine(result.GetProperty("floatExtensibleEnumCollection")[0].ToString()); + Console.WriteLine(result.GetProperty("floatFixedEnum").ToString()); + Console.WriteLine(result.GetProperty("floatFixedEnumWithIntValue").ToString()); + Console.WriteLine(result.GetProperty("floatFixedEnumCollection")[0].ToString()); + Console.WriteLine(result.GetProperty("intFixedEnum").ToString()); + Console.WriteLine(result.GetProperty("intFixedEnumCollection")[0].ToString()); + Console.WriteLine(result.GetProperty("stringFixedEnum").ToString()); + Console.WriteLine(result.GetProperty("requiredUnknown").ToString()); + Console.WriteLine(result.GetProperty("optionalUnknown").ToString()); + Console.WriteLine(result.GetProperty("requiredRecordUnknown").ToString()); + Console.WriteLine(result.GetProperty("optionalRecordUnknown").ToString()); + Console.WriteLine(result.GetProperty("readOnlyRequiredRecordUnknown").ToString()); + Console.WriteLine(result.GetProperty("readOnlyOptionalRecordUnknown").ToString()); + Console.WriteLine(result.GetProperty("modelWithRequiredNullable").GetProperty("requiredNullablePrimitive").ToString()); + Console.WriteLine(result.GetProperty("modelWithRequiredNullable").GetProperty("requiredExtensibleEnum").ToString()); + Console.WriteLine(result.GetProperty("modelWithRequiredNullable").GetProperty("requiredFixedEnum").ToString()); + Console.WriteLine(result.GetProperty("requiredBytes").ToString()); + } + + /// This sample shows how to call HelloAgain with all parameters. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public void Example_SampleTypeSpec_HelloAgain_AllParameters_Convenience() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + RoundTripModel action = new RoundTripModel( + "", + 0, + new StringFixedEnum[] { StringFixedEnum.One }, + new Dictionary + { + { "key", StringExtensibleEnum.One } + }, + new Thing( + "", + BinaryData.FromObjectAsJson(""), + "", + ThingRequiredNullableLiteralString1.SomeValue, + "", + new int[] { 0 }, + ""), + BinaryData.FromObjectAsJson(""), + new Dictionary + { + { "key", BinaryData.FromObjectAsJson("") } + }, + new ModelWithRequiredNullableProperties(0, StringExtensibleEnum.One, StringFixedEnum.One), + BinaryData.FromObjectAsJson("")); + ClientResult response = client.HelloAgain("", "", action); + + } + + /// This sample shows how to call HelloAgainAsync with all parameters. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public async Task Example_SampleTypeSpec_HelloAgain_AllParameters_Convenience_Async() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + RoundTripModel action = new RoundTripModel( + "", + 0, + new StringFixedEnum[] { StringFixedEnum.One }, + new Dictionary + { + { "key", StringExtensibleEnum.One } + }, + new Thing( + "", + BinaryData.FromObjectAsJson(""), + "", + ThingRequiredNullableLiteralString1.SomeValue, + "", + new int[] { 0 }, + ""), + BinaryData.FromObjectAsJson(""), + new Dictionary + { + { "key", BinaryData.FromObjectAsJson("") } + }, + new ModelWithRequiredNullableProperties(0, StringExtensibleEnum.One, StringFixedEnum.One), + BinaryData.FromObjectAsJson("")); + ClientResult response = await client.HelloAgainAsync("", "", action).ConfigureAwait(false); + + } + + /// This sample shows how to call NoContentType and parse the result. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public void Example_SampleTypeSpec_NoContentType_ShortVersion() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + using BinaryContent content = BinaryContent.Create(BinaryData.FromObjectAsJson(new + { + requiredString = "", + requiredInt = 0, + requiredCollection = new object[] { "1" }, + requiredDictionary = new + { + key = "1" + }, + requiredModel = new + { + name = "", + requiredUnion = "", + requiredLiteralString = "accept", + requiredNullableString = "", + requiredLiteralInt = 123, + requiredLiteralFloat = 1.23F, + requiredLiteralBool = false, + requiredNullableLiteralString = "someValue", + requiredBadDescription = "", + requiredNullableList = new object[] { 0 }, + propertyWithSpecialDocs = "" + }, + requiredUnknown = "", + requiredRecordUnknown = new + { + key = "" + }, + modelWithRequiredNullable = new + { + requiredNullablePrimitive = 0, + requiredExtensibleEnum = "1", + requiredFixedEnum = "1" + }, + requiredBytes = "" + })); + ClientResult response = client.NoContentType("", "", content); + + JsonElement result = JsonDocument.Parse(response.GetRawResponse().ContentStream).RootElement; + Console.WriteLine(result.GetProperty("requiredString").ToString()); + Console.WriteLine(result.GetProperty("requiredInt").ToString()); + Console.WriteLine(result.GetProperty("requiredCollection")[0].ToString()); + Console.WriteLine(result.GetProperty("requiredDictionary").ToString()); + Console.WriteLine(result.GetProperty("requiredModel").GetProperty("name").ToString()); + Console.WriteLine(result.GetProperty("requiredModel").GetProperty("requiredUnion").ToString()); + Console.WriteLine(result.GetProperty("requiredModel").GetProperty("requiredLiteralString").ToString()); + Console.WriteLine(result.GetProperty("requiredModel").GetProperty("requiredNullableString").ToString()); + Console.WriteLine(result.GetProperty("requiredModel").GetProperty("requiredLiteralInt").ToString()); + Console.WriteLine(result.GetProperty("requiredModel").GetProperty("requiredLiteralFloat").ToString()); + Console.WriteLine(result.GetProperty("requiredModel").GetProperty("requiredLiteralBool").ToString()); + Console.WriteLine(result.GetProperty("requiredModel").GetProperty("requiredNullableLiteralString").ToString()); + Console.WriteLine(result.GetProperty("requiredModel").GetProperty("requiredBadDescription").ToString()); + Console.WriteLine(result.GetProperty("requiredModel").GetProperty("requiredNullableList").ToString()); + Console.WriteLine(result.GetProperty("requiredModel").GetProperty("propertyWithSpecialDocs").ToString()); + Console.WriteLine(result.GetProperty("requiredUnknown").ToString()); + Console.WriteLine(result.GetProperty("requiredRecordUnknown").ToString()); + Console.WriteLine(result.GetProperty("readOnlyRequiredRecordUnknown").ToString()); + Console.WriteLine(result.GetProperty("modelWithRequiredNullable").GetProperty("requiredNullablePrimitive").ToString()); + Console.WriteLine(result.GetProperty("modelWithRequiredNullable").GetProperty("requiredExtensibleEnum").ToString()); + Console.WriteLine(result.GetProperty("modelWithRequiredNullable").GetProperty("requiredFixedEnum").ToString()); + Console.WriteLine(result.GetProperty("requiredBytes").ToString()); + } + + /// This sample shows how to call NoContentTypeAsync and parse the result. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public async Task Example_SampleTypeSpec_NoContentType_ShortVersion_Async() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + using BinaryContent content = BinaryContent.Create(BinaryData.FromObjectAsJson(new + { + requiredString = "", + requiredInt = 0, + requiredCollection = new object[] { "1" }, + requiredDictionary = new + { + key = "1" + }, + requiredModel = new + { + name = "", + requiredUnion = "", + requiredLiteralString = "accept", + requiredNullableString = "", + requiredLiteralInt = 123, + requiredLiteralFloat = 1.23F, + requiredLiteralBool = false, + requiredNullableLiteralString = "someValue", + requiredBadDescription = "", + requiredNullableList = new object[] { 0 }, + propertyWithSpecialDocs = "" + }, + requiredUnknown = "", + requiredRecordUnknown = new + { + key = "" + }, + modelWithRequiredNullable = new + { + requiredNullablePrimitive = 0, + requiredExtensibleEnum = "1", + requiredFixedEnum = "1" + }, + requiredBytes = "" + })); + ClientResult response = await client.NoContentTypeAsync("", "", content).ConfigureAwait(false); + + JsonElement result = JsonDocument.Parse(response.GetRawResponse().ContentStream).RootElement; + Console.WriteLine(result.GetProperty("requiredString").ToString()); + Console.WriteLine(result.GetProperty("requiredInt").ToString()); + Console.WriteLine(result.GetProperty("requiredCollection")[0].ToString()); + Console.WriteLine(result.GetProperty("requiredDictionary").ToString()); + Console.WriteLine(result.GetProperty("requiredModel").GetProperty("name").ToString()); + Console.WriteLine(result.GetProperty("requiredModel").GetProperty("requiredUnion").ToString()); + Console.WriteLine(result.GetProperty("requiredModel").GetProperty("requiredLiteralString").ToString()); + Console.WriteLine(result.GetProperty("requiredModel").GetProperty("requiredNullableString").ToString()); + Console.WriteLine(result.GetProperty("requiredModel").GetProperty("requiredLiteralInt").ToString()); + Console.WriteLine(result.GetProperty("requiredModel").GetProperty("requiredLiteralFloat").ToString()); + Console.WriteLine(result.GetProperty("requiredModel").GetProperty("requiredLiteralBool").ToString()); + Console.WriteLine(result.GetProperty("requiredModel").GetProperty("requiredNullableLiteralString").ToString()); + Console.WriteLine(result.GetProperty("requiredModel").GetProperty("requiredBadDescription").ToString()); + Console.WriteLine(result.GetProperty("requiredModel").GetProperty("requiredNullableList").ToString()); + Console.WriteLine(result.GetProperty("requiredModel").GetProperty("propertyWithSpecialDocs").ToString()); + Console.WriteLine(result.GetProperty("requiredUnknown").ToString()); + Console.WriteLine(result.GetProperty("requiredRecordUnknown").ToString()); + Console.WriteLine(result.GetProperty("readOnlyRequiredRecordUnknown").ToString()); + Console.WriteLine(result.GetProperty("modelWithRequiredNullable").GetProperty("requiredNullablePrimitive").ToString()); + Console.WriteLine(result.GetProperty("modelWithRequiredNullable").GetProperty("requiredExtensibleEnum").ToString()); + Console.WriteLine(result.GetProperty("modelWithRequiredNullable").GetProperty("requiredFixedEnum").ToString()); + Console.WriteLine(result.GetProperty("requiredBytes").ToString()); + } + + /// This sample shows how to call NoContentType. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public void Example_SampleTypeSpec_NoContentType_ShortVersion_Convenience() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + Wrapper info = null; + ClientResult response = client.NoContentType(info); + + } + + /// This sample shows how to call NoContentTypeAsync. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public async Task Example_SampleTypeSpec_NoContentType_ShortVersion_Convenience_Async() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + Wrapper info = null; + ClientResult response = await client.NoContentTypeAsync(info).ConfigureAwait(false); + + } + + /// This sample shows how to call NoContentType with all parameters and request content and parse the result. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public void Example_SampleTypeSpec_NoContentType_AllParameters() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + using BinaryContent content = BinaryContent.Create(BinaryData.FromObjectAsJson(new + { + requiredString = "", + requiredInt = 0, + requiredCollection = new object[] { "1" }, + requiredDictionary = new + { + key = "1" + }, + requiredModel = new + { + name = "", + requiredUnion = "", + requiredLiteralString = "accept", + requiredNullableString = "", + optionalNullableString = "", + requiredLiteralInt = 123, + requiredLiteralFloat = 1.23F, + requiredLiteralBool = false, + optionalLiteralString = "reject", + requiredNullableLiteralString = "someValue", + optionalLiteralInt = 456, + optionalLiteralFloat = 4.56F, + optionalLiteralBool = true, + requiredBadDescription = "", + optionalNullableList = new object[] { 0 }, + requiredNullableList = new object[] { 0 }, + propertyWithSpecialDocs = "" + }, + intExtensibleEnum = 1, + intExtensibleEnumCollection = new object[] { 1 }, + floatExtensibleEnum = 1.1F, + floatExtensibleEnumWithIntValue = 1F, + floatExtensibleEnumCollection = new object[] { 1.1F }, + floatFixedEnum = 1.1F, + floatFixedEnumWithIntValue = 1, + floatFixedEnumCollection = new object[] { 1.1F }, + intFixedEnum = 1, + intFixedEnumCollection = new object[] { 1 }, + stringFixedEnum = "1", + requiredUnknown = "", + optionalUnknown = "", + requiredRecordUnknown = new + { + key = "" + }, + optionalRecordUnknown = new + { + key = "" + }, + modelWithRequiredNullable = new + { + requiredNullablePrimitive = 0, + requiredExtensibleEnum = "1", + requiredFixedEnum = "1" + }, + requiredBytes = "" + })); + ClientResult response = client.NoContentType("", "", content); + + JsonElement result = JsonDocument.Parse(response.GetRawResponse().ContentStream).RootElement; + Console.WriteLine(result.GetProperty("requiredString").ToString()); + Console.WriteLine(result.GetProperty("requiredInt").ToString()); + Console.WriteLine(result.GetProperty("requiredCollection")[0].ToString()); + Console.WriteLine(result.GetProperty("requiredDictionary").ToString()); + Console.WriteLine(result.GetProperty("requiredModel").GetProperty("name").ToString()); + Console.WriteLine(result.GetProperty("requiredModel").GetProperty("requiredUnion").ToString()); + Console.WriteLine(result.GetProperty("requiredModel").GetProperty("requiredLiteralString").ToString()); + Console.WriteLine(result.GetProperty("requiredModel").GetProperty("requiredNullableString").ToString()); + Console.WriteLine(result.GetProperty("requiredModel").GetProperty("optionalNullableString").ToString()); + Console.WriteLine(result.GetProperty("requiredModel").GetProperty("requiredLiteralInt").ToString()); + Console.WriteLine(result.GetProperty("requiredModel").GetProperty("requiredLiteralFloat").ToString()); + Console.WriteLine(result.GetProperty("requiredModel").GetProperty("requiredLiteralBool").ToString()); + Console.WriteLine(result.GetProperty("requiredModel").GetProperty("optionalLiteralString").ToString()); + Console.WriteLine(result.GetProperty("requiredModel").GetProperty("requiredNullableLiteralString").ToString()); + Console.WriteLine(result.GetProperty("requiredModel").GetProperty("optionalLiteralInt").ToString()); + Console.WriteLine(result.GetProperty("requiredModel").GetProperty("optionalLiteralFloat").ToString()); + Console.WriteLine(result.GetProperty("requiredModel").GetProperty("optionalLiteralBool").ToString()); + Console.WriteLine(result.GetProperty("requiredModel").GetProperty("requiredBadDescription").ToString()); + Console.WriteLine(result.GetProperty("requiredModel").GetProperty("optionalNullableList").ToString()); + Console.WriteLine(result.GetProperty("requiredModel").GetProperty("requiredNullableList").ToString()); + Console.WriteLine(result.GetProperty("requiredModel").GetProperty("propertyWithSpecialDocs").ToString()); + Console.WriteLine(result.GetProperty("intExtensibleEnum").ToString()); + Console.WriteLine(result.GetProperty("intExtensibleEnumCollection")[0].ToString()); + Console.WriteLine(result.GetProperty("floatExtensibleEnum").ToString()); + Console.WriteLine(result.GetProperty("floatExtensibleEnumWithIntValue").ToString()); + Console.WriteLine(result.GetProperty("floatExtensibleEnumCollection")[0].ToString()); + Console.WriteLine(result.GetProperty("floatFixedEnum").ToString()); + Console.WriteLine(result.GetProperty("floatFixedEnumWithIntValue").ToString()); + Console.WriteLine(result.GetProperty("floatFixedEnumCollection")[0].ToString()); + Console.WriteLine(result.GetProperty("intFixedEnum").ToString()); + Console.WriteLine(result.GetProperty("intFixedEnumCollection")[0].ToString()); + Console.WriteLine(result.GetProperty("stringFixedEnum").ToString()); + Console.WriteLine(result.GetProperty("requiredUnknown").ToString()); + Console.WriteLine(result.GetProperty("optionalUnknown").ToString()); + Console.WriteLine(result.GetProperty("requiredRecordUnknown").ToString()); + Console.WriteLine(result.GetProperty("optionalRecordUnknown").ToString()); + Console.WriteLine(result.GetProperty("readOnlyRequiredRecordUnknown").ToString()); + Console.WriteLine(result.GetProperty("readOnlyOptionalRecordUnknown").ToString()); + Console.WriteLine(result.GetProperty("modelWithRequiredNullable").GetProperty("requiredNullablePrimitive").ToString()); + Console.WriteLine(result.GetProperty("modelWithRequiredNullable").GetProperty("requiredExtensibleEnum").ToString()); + Console.WriteLine(result.GetProperty("modelWithRequiredNullable").GetProperty("requiredFixedEnum").ToString()); + Console.WriteLine(result.GetProperty("requiredBytes").ToString()); + } + + /// This sample shows how to call NoContentTypeAsync with all parameters and request content and parse the result. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public async Task Example_SampleTypeSpec_NoContentType_AllParameters_Async() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + using BinaryContent content = BinaryContent.Create(BinaryData.FromObjectAsJson(new + { + requiredString = "", + requiredInt = 0, + requiredCollection = new object[] { "1" }, + requiredDictionary = new + { + key = "1" + }, + requiredModel = new + { + name = "", + requiredUnion = "", + requiredLiteralString = "accept", + requiredNullableString = "", + optionalNullableString = "", + requiredLiteralInt = 123, + requiredLiteralFloat = 1.23F, + requiredLiteralBool = false, + optionalLiteralString = "reject", + requiredNullableLiteralString = "someValue", + optionalLiteralInt = 456, + optionalLiteralFloat = 4.56F, + optionalLiteralBool = true, + requiredBadDescription = "", + optionalNullableList = new object[] { 0 }, + requiredNullableList = new object[] { 0 }, + propertyWithSpecialDocs = "" + }, + intExtensibleEnum = 1, + intExtensibleEnumCollection = new object[] { 1 }, + floatExtensibleEnum = 1.1F, + floatExtensibleEnumWithIntValue = 1F, + floatExtensibleEnumCollection = new object[] { 1.1F }, + floatFixedEnum = 1.1F, + floatFixedEnumWithIntValue = 1, + floatFixedEnumCollection = new object[] { 1.1F }, + intFixedEnum = 1, + intFixedEnumCollection = new object[] { 1 }, + stringFixedEnum = "1", + requiredUnknown = "", + optionalUnknown = "", + requiredRecordUnknown = new + { + key = "" + }, + optionalRecordUnknown = new + { + key = "" + }, + modelWithRequiredNullable = new + { + requiredNullablePrimitive = 0, + requiredExtensibleEnum = "1", + requiredFixedEnum = "1" + }, + requiredBytes = "" + })); + ClientResult response = await client.NoContentTypeAsync("", "", content).ConfigureAwait(false); + + JsonElement result = JsonDocument.Parse(response.GetRawResponse().ContentStream).RootElement; + Console.WriteLine(result.GetProperty("requiredString").ToString()); + Console.WriteLine(result.GetProperty("requiredInt").ToString()); + Console.WriteLine(result.GetProperty("requiredCollection")[0].ToString()); + Console.WriteLine(result.GetProperty("requiredDictionary").ToString()); + Console.WriteLine(result.GetProperty("requiredModel").GetProperty("name").ToString()); + Console.WriteLine(result.GetProperty("requiredModel").GetProperty("requiredUnion").ToString()); + Console.WriteLine(result.GetProperty("requiredModel").GetProperty("requiredLiteralString").ToString()); + Console.WriteLine(result.GetProperty("requiredModel").GetProperty("requiredNullableString").ToString()); + Console.WriteLine(result.GetProperty("requiredModel").GetProperty("optionalNullableString").ToString()); + Console.WriteLine(result.GetProperty("requiredModel").GetProperty("requiredLiteralInt").ToString()); + Console.WriteLine(result.GetProperty("requiredModel").GetProperty("requiredLiteralFloat").ToString()); + Console.WriteLine(result.GetProperty("requiredModel").GetProperty("requiredLiteralBool").ToString()); + Console.WriteLine(result.GetProperty("requiredModel").GetProperty("optionalLiteralString").ToString()); + Console.WriteLine(result.GetProperty("requiredModel").GetProperty("requiredNullableLiteralString").ToString()); + Console.WriteLine(result.GetProperty("requiredModel").GetProperty("optionalLiteralInt").ToString()); + Console.WriteLine(result.GetProperty("requiredModel").GetProperty("optionalLiteralFloat").ToString()); + Console.WriteLine(result.GetProperty("requiredModel").GetProperty("optionalLiteralBool").ToString()); + Console.WriteLine(result.GetProperty("requiredModel").GetProperty("requiredBadDescription").ToString()); + Console.WriteLine(result.GetProperty("requiredModel").GetProperty("optionalNullableList").ToString()); + Console.WriteLine(result.GetProperty("requiredModel").GetProperty("requiredNullableList").ToString()); + Console.WriteLine(result.GetProperty("requiredModel").GetProperty("propertyWithSpecialDocs").ToString()); + Console.WriteLine(result.GetProperty("intExtensibleEnum").ToString()); + Console.WriteLine(result.GetProperty("intExtensibleEnumCollection")[0].ToString()); + Console.WriteLine(result.GetProperty("floatExtensibleEnum").ToString()); + Console.WriteLine(result.GetProperty("floatExtensibleEnumWithIntValue").ToString()); + Console.WriteLine(result.GetProperty("floatExtensibleEnumCollection")[0].ToString()); + Console.WriteLine(result.GetProperty("floatFixedEnum").ToString()); + Console.WriteLine(result.GetProperty("floatFixedEnumWithIntValue").ToString()); + Console.WriteLine(result.GetProperty("floatFixedEnumCollection")[0].ToString()); + Console.WriteLine(result.GetProperty("intFixedEnum").ToString()); + Console.WriteLine(result.GetProperty("intFixedEnumCollection")[0].ToString()); + Console.WriteLine(result.GetProperty("stringFixedEnum").ToString()); + Console.WriteLine(result.GetProperty("requiredUnknown").ToString()); + Console.WriteLine(result.GetProperty("optionalUnknown").ToString()); + Console.WriteLine(result.GetProperty("requiredRecordUnknown").ToString()); + Console.WriteLine(result.GetProperty("optionalRecordUnknown").ToString()); + Console.WriteLine(result.GetProperty("readOnlyRequiredRecordUnknown").ToString()); + Console.WriteLine(result.GetProperty("readOnlyOptionalRecordUnknown").ToString()); + Console.WriteLine(result.GetProperty("modelWithRequiredNullable").GetProperty("requiredNullablePrimitive").ToString()); + Console.WriteLine(result.GetProperty("modelWithRequiredNullable").GetProperty("requiredExtensibleEnum").ToString()); + Console.WriteLine(result.GetProperty("modelWithRequiredNullable").GetProperty("requiredFixedEnum").ToString()); + Console.WriteLine(result.GetProperty("requiredBytes").ToString()); + } + + /// This sample shows how to call NoContentType with all parameters. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public void Example_SampleTypeSpec_NoContentType_AllParameters_Convenience() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + Wrapper info = null; + ClientResult response = client.NoContentType(info); + + } + + /// This sample shows how to call NoContentTypeAsync with all parameters. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public async Task Example_SampleTypeSpec_NoContentType_AllParameters_Convenience_Async() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + Wrapper info = null; + ClientResult response = await client.NoContentTypeAsync(info).ConfigureAwait(false); + + } + + /// This sample shows how to call HelloDemo2 and parse the result. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public void Example_SampleTypeSpec_HelloDemo2_ShortVersion() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + ClientResult response = client.HelloDemo2(null); + + JsonElement result = JsonDocument.Parse(response.GetRawResponse().ContentStream).RootElement; + Console.WriteLine(result.GetProperty("name").ToString()); + Console.WriteLine(result.GetProperty("requiredUnion").ToString()); + Console.WriteLine(result.GetProperty("requiredLiteralString").ToString()); + Console.WriteLine(result.GetProperty("requiredNullableString").ToString()); + Console.WriteLine(result.GetProperty("requiredLiteralInt").ToString()); + Console.WriteLine(result.GetProperty("requiredLiteralFloat").ToString()); + Console.WriteLine(result.GetProperty("requiredLiteralBool").ToString()); + Console.WriteLine(result.GetProperty("requiredNullableLiteralString").ToString()); + Console.WriteLine(result.GetProperty("requiredBadDescription").ToString()); + Console.WriteLine(result.GetProperty("requiredNullableList").ToString()); + Console.WriteLine(result.GetProperty("propertyWithSpecialDocs").ToString()); + } + + /// This sample shows how to call HelloDemo2Async and parse the result. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public async Task Example_SampleTypeSpec_HelloDemo2_ShortVersion_Async() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + ClientResult response = await client.HelloDemo2Async(null).ConfigureAwait(false); + + JsonElement result = JsonDocument.Parse(response.GetRawResponse().ContentStream).RootElement; + Console.WriteLine(result.GetProperty("name").ToString()); + Console.WriteLine(result.GetProperty("requiredUnion").ToString()); + Console.WriteLine(result.GetProperty("requiredLiteralString").ToString()); + Console.WriteLine(result.GetProperty("requiredNullableString").ToString()); + Console.WriteLine(result.GetProperty("requiredLiteralInt").ToString()); + Console.WriteLine(result.GetProperty("requiredLiteralFloat").ToString()); + Console.WriteLine(result.GetProperty("requiredLiteralBool").ToString()); + Console.WriteLine(result.GetProperty("requiredNullableLiteralString").ToString()); + Console.WriteLine(result.GetProperty("requiredBadDescription").ToString()); + Console.WriteLine(result.GetProperty("requiredNullableList").ToString()); + Console.WriteLine(result.GetProperty("propertyWithSpecialDocs").ToString()); + } + + /// This sample shows how to call HelloDemo2. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public void Example_SampleTypeSpec_HelloDemo2_ShortVersion_Convenience() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + ClientResult response = client.HelloDemo2(); + + } + + /// This sample shows how to call HelloDemo2Async. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public async Task Example_SampleTypeSpec_HelloDemo2_ShortVersion_Convenience_Async() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + ClientResult response = await client.HelloDemo2Async().ConfigureAwait(false); + + } + + /// This sample shows how to call HelloDemo2 with all request content and parse the result. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public void Example_SampleTypeSpec_HelloDemo2_AllParameters() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + ClientResult response = client.HelloDemo2(null); + + JsonElement result = JsonDocument.Parse(response.GetRawResponse().ContentStream).RootElement; + Console.WriteLine(result.GetProperty("name").ToString()); + Console.WriteLine(result.GetProperty("requiredUnion").ToString()); + Console.WriteLine(result.GetProperty("requiredLiteralString").ToString()); + Console.WriteLine(result.GetProperty("requiredNullableString").ToString()); + Console.WriteLine(result.GetProperty("optionalNullableString").ToString()); + Console.WriteLine(result.GetProperty("requiredLiteralInt").ToString()); + Console.WriteLine(result.GetProperty("requiredLiteralFloat").ToString()); + Console.WriteLine(result.GetProperty("requiredLiteralBool").ToString()); + Console.WriteLine(result.GetProperty("optionalLiteralString").ToString()); + Console.WriteLine(result.GetProperty("requiredNullableLiteralString").ToString()); + Console.WriteLine(result.GetProperty("optionalLiteralInt").ToString()); + Console.WriteLine(result.GetProperty("optionalLiteralFloat").ToString()); + Console.WriteLine(result.GetProperty("optionalLiteralBool").ToString()); + Console.WriteLine(result.GetProperty("requiredBadDescription").ToString()); + Console.WriteLine(result.GetProperty("optionalNullableList").ToString()); + Console.WriteLine(result.GetProperty("requiredNullableList").ToString()); + Console.WriteLine(result.GetProperty("propertyWithSpecialDocs").ToString()); + } + + /// This sample shows how to call HelloDemo2Async with all request content and parse the result. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public async Task Example_SampleTypeSpec_HelloDemo2_AllParameters_Async() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + ClientResult response = await client.HelloDemo2Async(null).ConfigureAwait(false); + + JsonElement result = JsonDocument.Parse(response.GetRawResponse().ContentStream).RootElement; + Console.WriteLine(result.GetProperty("name").ToString()); + Console.WriteLine(result.GetProperty("requiredUnion").ToString()); + Console.WriteLine(result.GetProperty("requiredLiteralString").ToString()); + Console.WriteLine(result.GetProperty("requiredNullableString").ToString()); + Console.WriteLine(result.GetProperty("optionalNullableString").ToString()); + Console.WriteLine(result.GetProperty("requiredLiteralInt").ToString()); + Console.WriteLine(result.GetProperty("requiredLiteralFloat").ToString()); + Console.WriteLine(result.GetProperty("requiredLiteralBool").ToString()); + Console.WriteLine(result.GetProperty("optionalLiteralString").ToString()); + Console.WriteLine(result.GetProperty("requiredNullableLiteralString").ToString()); + Console.WriteLine(result.GetProperty("optionalLiteralInt").ToString()); + Console.WriteLine(result.GetProperty("optionalLiteralFloat").ToString()); + Console.WriteLine(result.GetProperty("optionalLiteralBool").ToString()); + Console.WriteLine(result.GetProperty("requiredBadDescription").ToString()); + Console.WriteLine(result.GetProperty("optionalNullableList").ToString()); + Console.WriteLine(result.GetProperty("requiredNullableList").ToString()); + Console.WriteLine(result.GetProperty("propertyWithSpecialDocs").ToString()); + } + + /// This sample shows how to call HelloDemo2 with all parameters. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public void Example_SampleTypeSpec_HelloDemo2_AllParameters_Convenience() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + ClientResult response = client.HelloDemo2(); + + } + + /// This sample shows how to call HelloDemo2Async with all parameters. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public async Task Example_SampleTypeSpec_HelloDemo2_AllParameters_Convenience_Async() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + ClientResult response = await client.HelloDemo2Async().ConfigureAwait(false); + + } + + /// This sample shows how to call CreateLiteral and parse the result. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public void Example_SampleTypeSpec_CreateLiteral_ShortVersion() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + using BinaryContent content = BinaryContent.Create(BinaryData.FromObjectAsJson(new + { + name = "", + requiredUnion = "", + requiredLiteralString = "accept", + requiredNullableString = "", + requiredLiteralInt = 123, + requiredLiteralFloat = 1.23F, + requiredLiteralBool = false, + requiredNullableLiteralString = "someValue", + requiredBadDescription = "", + requiredNullableList = new object[] { 0 }, + propertyWithSpecialDocs = "" + })); + ClientResult response = client.CreateLiteral(content); + + JsonElement result = JsonDocument.Parse(response.GetRawResponse().ContentStream).RootElement; + Console.WriteLine(result.GetProperty("name").ToString()); + Console.WriteLine(result.GetProperty("requiredUnion").ToString()); + Console.WriteLine(result.GetProperty("requiredLiteralString").ToString()); + Console.WriteLine(result.GetProperty("requiredNullableString").ToString()); + Console.WriteLine(result.GetProperty("requiredLiteralInt").ToString()); + Console.WriteLine(result.GetProperty("requiredLiteralFloat").ToString()); + Console.WriteLine(result.GetProperty("requiredLiteralBool").ToString()); + Console.WriteLine(result.GetProperty("requiredNullableLiteralString").ToString()); + Console.WriteLine(result.GetProperty("requiredBadDescription").ToString()); + Console.WriteLine(result.GetProperty("requiredNullableList").ToString()); + Console.WriteLine(result.GetProperty("propertyWithSpecialDocs").ToString()); + } + + /// This sample shows how to call CreateLiteralAsync and parse the result. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public async Task Example_SampleTypeSpec_CreateLiteral_ShortVersion_Async() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + using BinaryContent content = BinaryContent.Create(BinaryData.FromObjectAsJson(new + { + name = "", + requiredUnion = "", + requiredLiteralString = "accept", + requiredNullableString = "", + requiredLiteralInt = 123, + requiredLiteralFloat = 1.23F, + requiredLiteralBool = false, + requiredNullableLiteralString = "someValue", + requiredBadDescription = "", + requiredNullableList = new object[] { 0 }, + propertyWithSpecialDocs = "" + })); + ClientResult response = await client.CreateLiteralAsync(content).ConfigureAwait(false); + + JsonElement result = JsonDocument.Parse(response.GetRawResponse().ContentStream).RootElement; + Console.WriteLine(result.GetProperty("name").ToString()); + Console.WriteLine(result.GetProperty("requiredUnion").ToString()); + Console.WriteLine(result.GetProperty("requiredLiteralString").ToString()); + Console.WriteLine(result.GetProperty("requiredNullableString").ToString()); + Console.WriteLine(result.GetProperty("requiredLiteralInt").ToString()); + Console.WriteLine(result.GetProperty("requiredLiteralFloat").ToString()); + Console.WriteLine(result.GetProperty("requiredLiteralBool").ToString()); + Console.WriteLine(result.GetProperty("requiredNullableLiteralString").ToString()); + Console.WriteLine(result.GetProperty("requiredBadDescription").ToString()); + Console.WriteLine(result.GetProperty("requiredNullableList").ToString()); + Console.WriteLine(result.GetProperty("propertyWithSpecialDocs").ToString()); + } + + /// This sample shows how to call CreateLiteral. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public void Example_SampleTypeSpec_CreateLiteral_ShortVersion_Convenience() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + Thing body = new Thing( + "", + BinaryData.FromObjectAsJson(""), + "", + ThingRequiredNullableLiteralString1.SomeValue, + "", + new int[] { 0 }, + ""); + ClientResult response = client.CreateLiteral(body); + + } + + /// This sample shows how to call CreateLiteralAsync. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public async Task Example_SampleTypeSpec_CreateLiteral_ShortVersion_Convenience_Async() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + Thing body = new Thing( + "", + BinaryData.FromObjectAsJson(""), + "", + ThingRequiredNullableLiteralString1.SomeValue, + "", + new int[] { 0 }, + ""); + ClientResult response = await client.CreateLiteralAsync(body).ConfigureAwait(false); + + } + + /// This sample shows how to call CreateLiteral with all request content and parse the result. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public void Example_SampleTypeSpec_CreateLiteral_AllParameters() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + using BinaryContent content = BinaryContent.Create(BinaryData.FromObjectAsJson(new + { + name = "", + requiredUnion = "", + requiredLiteralString = "accept", + requiredNullableString = "", + optionalNullableString = "", + requiredLiteralInt = 123, + requiredLiteralFloat = 1.23F, + requiredLiteralBool = false, + optionalLiteralString = "reject", + requiredNullableLiteralString = "someValue", + optionalLiteralInt = 456, + optionalLiteralFloat = 4.56F, + optionalLiteralBool = true, + requiredBadDescription = "", + optionalNullableList = new object[] { 0 }, + requiredNullableList = new object[] { 0 }, + propertyWithSpecialDocs = "" + })); + ClientResult response = client.CreateLiteral(content); + + JsonElement result = JsonDocument.Parse(response.GetRawResponse().ContentStream).RootElement; + Console.WriteLine(result.GetProperty("name").ToString()); + Console.WriteLine(result.GetProperty("requiredUnion").ToString()); + Console.WriteLine(result.GetProperty("requiredLiteralString").ToString()); + Console.WriteLine(result.GetProperty("requiredNullableString").ToString()); + Console.WriteLine(result.GetProperty("optionalNullableString").ToString()); + Console.WriteLine(result.GetProperty("requiredLiteralInt").ToString()); + Console.WriteLine(result.GetProperty("requiredLiteralFloat").ToString()); + Console.WriteLine(result.GetProperty("requiredLiteralBool").ToString()); + Console.WriteLine(result.GetProperty("optionalLiteralString").ToString()); + Console.WriteLine(result.GetProperty("requiredNullableLiteralString").ToString()); + Console.WriteLine(result.GetProperty("optionalLiteralInt").ToString()); + Console.WriteLine(result.GetProperty("optionalLiteralFloat").ToString()); + Console.WriteLine(result.GetProperty("optionalLiteralBool").ToString()); + Console.WriteLine(result.GetProperty("requiredBadDescription").ToString()); + Console.WriteLine(result.GetProperty("optionalNullableList").ToString()); + Console.WriteLine(result.GetProperty("requiredNullableList").ToString()); + Console.WriteLine(result.GetProperty("propertyWithSpecialDocs").ToString()); + } + + /// This sample shows how to call CreateLiteralAsync with all request content and parse the result. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public async Task Example_SampleTypeSpec_CreateLiteral_AllParameters_Async() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + using BinaryContent content = BinaryContent.Create(BinaryData.FromObjectAsJson(new + { + name = "", + requiredUnion = "", + requiredLiteralString = "accept", + requiredNullableString = "", + optionalNullableString = "", + requiredLiteralInt = 123, + requiredLiteralFloat = 1.23F, + requiredLiteralBool = false, + optionalLiteralString = "reject", + requiredNullableLiteralString = "someValue", + optionalLiteralInt = 456, + optionalLiteralFloat = 4.56F, + optionalLiteralBool = true, + requiredBadDescription = "", + optionalNullableList = new object[] { 0 }, + requiredNullableList = new object[] { 0 }, + propertyWithSpecialDocs = "" + })); + ClientResult response = await client.CreateLiteralAsync(content).ConfigureAwait(false); + + JsonElement result = JsonDocument.Parse(response.GetRawResponse().ContentStream).RootElement; + Console.WriteLine(result.GetProperty("name").ToString()); + Console.WriteLine(result.GetProperty("requiredUnion").ToString()); + Console.WriteLine(result.GetProperty("requiredLiteralString").ToString()); + Console.WriteLine(result.GetProperty("requiredNullableString").ToString()); + Console.WriteLine(result.GetProperty("optionalNullableString").ToString()); + Console.WriteLine(result.GetProperty("requiredLiteralInt").ToString()); + Console.WriteLine(result.GetProperty("requiredLiteralFloat").ToString()); + Console.WriteLine(result.GetProperty("requiredLiteralBool").ToString()); + Console.WriteLine(result.GetProperty("optionalLiteralString").ToString()); + Console.WriteLine(result.GetProperty("requiredNullableLiteralString").ToString()); + Console.WriteLine(result.GetProperty("optionalLiteralInt").ToString()); + Console.WriteLine(result.GetProperty("optionalLiteralFloat").ToString()); + Console.WriteLine(result.GetProperty("optionalLiteralBool").ToString()); + Console.WriteLine(result.GetProperty("requiredBadDescription").ToString()); + Console.WriteLine(result.GetProperty("optionalNullableList").ToString()); + Console.WriteLine(result.GetProperty("requiredNullableList").ToString()); + Console.WriteLine(result.GetProperty("propertyWithSpecialDocs").ToString()); + } + + /// This sample shows how to call CreateLiteral with all parameters. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public void Example_SampleTypeSpec_CreateLiteral_AllParameters_Convenience() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + Thing body = new Thing( + "", + BinaryData.FromObjectAsJson(""), + "", + ThingRequiredNullableLiteralString1.SomeValue, + "", + new int[] { 0 }, + ""); + ClientResult response = client.CreateLiteral(body); + + } + + /// This sample shows how to call CreateLiteralAsync with all parameters. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public async Task Example_SampleTypeSpec_CreateLiteral_AllParameters_Convenience_Async() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + Thing body = new Thing( + "", + BinaryData.FromObjectAsJson(""), + "", + ThingRequiredNullableLiteralString1.SomeValue, + "", + new int[] { 0 }, + ""); + ClientResult response = await client.CreateLiteralAsync(body).ConfigureAwait(false); + + } + + /// This sample shows how to call HelloLiteral and parse the result. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public void Example_SampleTypeSpec_HelloLiteral_ShortVersion() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + ClientResult response = client.HelloLiteral(null); + + JsonElement result = JsonDocument.Parse(response.GetRawResponse().ContentStream).RootElement; + Console.WriteLine(result.GetProperty("name").ToString()); + Console.WriteLine(result.GetProperty("requiredUnion").ToString()); + Console.WriteLine(result.GetProperty("requiredLiteralString").ToString()); + Console.WriteLine(result.GetProperty("requiredNullableString").ToString()); + Console.WriteLine(result.GetProperty("requiredLiteralInt").ToString()); + Console.WriteLine(result.GetProperty("requiredLiteralFloat").ToString()); + Console.WriteLine(result.GetProperty("requiredLiteralBool").ToString()); + Console.WriteLine(result.GetProperty("requiredNullableLiteralString").ToString()); + Console.WriteLine(result.GetProperty("requiredBadDescription").ToString()); + Console.WriteLine(result.GetProperty("requiredNullableList").ToString()); + Console.WriteLine(result.GetProperty("propertyWithSpecialDocs").ToString()); + } + + /// This sample shows how to call HelloLiteralAsync and parse the result. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public async Task Example_SampleTypeSpec_HelloLiteral_ShortVersion_Async() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + ClientResult response = await client.HelloLiteralAsync(null).ConfigureAwait(false); + + JsonElement result = JsonDocument.Parse(response.GetRawResponse().ContentStream).RootElement; + Console.WriteLine(result.GetProperty("name").ToString()); + Console.WriteLine(result.GetProperty("requiredUnion").ToString()); + Console.WriteLine(result.GetProperty("requiredLiteralString").ToString()); + Console.WriteLine(result.GetProperty("requiredNullableString").ToString()); + Console.WriteLine(result.GetProperty("requiredLiteralInt").ToString()); + Console.WriteLine(result.GetProperty("requiredLiteralFloat").ToString()); + Console.WriteLine(result.GetProperty("requiredLiteralBool").ToString()); + Console.WriteLine(result.GetProperty("requiredNullableLiteralString").ToString()); + Console.WriteLine(result.GetProperty("requiredBadDescription").ToString()); + Console.WriteLine(result.GetProperty("requiredNullableList").ToString()); + Console.WriteLine(result.GetProperty("propertyWithSpecialDocs").ToString()); + } + + /// This sample shows how to call HelloLiteral. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public void Example_SampleTypeSpec_HelloLiteral_ShortVersion_Convenience() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + ClientResult response = client.HelloLiteral(); + + } + + /// This sample shows how to call HelloLiteralAsync. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public async Task Example_SampleTypeSpec_HelloLiteral_ShortVersion_Convenience_Async() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + ClientResult response = await client.HelloLiteralAsync().ConfigureAwait(false); + + } + + /// This sample shows how to call HelloLiteral with all request content and parse the result. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public void Example_SampleTypeSpec_HelloLiteral_AllParameters() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + ClientResult response = client.HelloLiteral(null); + + JsonElement result = JsonDocument.Parse(response.GetRawResponse().ContentStream).RootElement; + Console.WriteLine(result.GetProperty("name").ToString()); + Console.WriteLine(result.GetProperty("requiredUnion").ToString()); + Console.WriteLine(result.GetProperty("requiredLiteralString").ToString()); + Console.WriteLine(result.GetProperty("requiredNullableString").ToString()); + Console.WriteLine(result.GetProperty("optionalNullableString").ToString()); + Console.WriteLine(result.GetProperty("requiredLiteralInt").ToString()); + Console.WriteLine(result.GetProperty("requiredLiteralFloat").ToString()); + Console.WriteLine(result.GetProperty("requiredLiteralBool").ToString()); + Console.WriteLine(result.GetProperty("optionalLiteralString").ToString()); + Console.WriteLine(result.GetProperty("requiredNullableLiteralString").ToString()); + Console.WriteLine(result.GetProperty("optionalLiteralInt").ToString()); + Console.WriteLine(result.GetProperty("optionalLiteralFloat").ToString()); + Console.WriteLine(result.GetProperty("optionalLiteralBool").ToString()); + Console.WriteLine(result.GetProperty("requiredBadDescription").ToString()); + Console.WriteLine(result.GetProperty("optionalNullableList").ToString()); + Console.WriteLine(result.GetProperty("requiredNullableList").ToString()); + Console.WriteLine(result.GetProperty("propertyWithSpecialDocs").ToString()); + } + + /// This sample shows how to call HelloLiteralAsync with all request content and parse the result. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public async Task Example_SampleTypeSpec_HelloLiteral_AllParameters_Async() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + ClientResult response = await client.HelloLiteralAsync(null).ConfigureAwait(false); + + JsonElement result = JsonDocument.Parse(response.GetRawResponse().ContentStream).RootElement; + Console.WriteLine(result.GetProperty("name").ToString()); + Console.WriteLine(result.GetProperty("requiredUnion").ToString()); + Console.WriteLine(result.GetProperty("requiredLiteralString").ToString()); + Console.WriteLine(result.GetProperty("requiredNullableString").ToString()); + Console.WriteLine(result.GetProperty("optionalNullableString").ToString()); + Console.WriteLine(result.GetProperty("requiredLiteralInt").ToString()); + Console.WriteLine(result.GetProperty("requiredLiteralFloat").ToString()); + Console.WriteLine(result.GetProperty("requiredLiteralBool").ToString()); + Console.WriteLine(result.GetProperty("optionalLiteralString").ToString()); + Console.WriteLine(result.GetProperty("requiredNullableLiteralString").ToString()); + Console.WriteLine(result.GetProperty("optionalLiteralInt").ToString()); + Console.WriteLine(result.GetProperty("optionalLiteralFloat").ToString()); + Console.WriteLine(result.GetProperty("optionalLiteralBool").ToString()); + Console.WriteLine(result.GetProperty("requiredBadDescription").ToString()); + Console.WriteLine(result.GetProperty("optionalNullableList").ToString()); + Console.WriteLine(result.GetProperty("requiredNullableList").ToString()); + Console.WriteLine(result.GetProperty("propertyWithSpecialDocs").ToString()); + } + + /// This sample shows how to call HelloLiteral with all parameters. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public void Example_SampleTypeSpec_HelloLiteral_AllParameters_Convenience() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + ClientResult response = client.HelloLiteral(); + + } + + /// This sample shows how to call HelloLiteralAsync with all parameters. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public async Task Example_SampleTypeSpec_HelloLiteral_AllParameters_Convenience_Async() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + ClientResult response = await client.HelloLiteralAsync().ConfigureAwait(false); + + } + + /// This sample shows how to call TopAction and parse the result. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public void Example_SampleTypeSpec_TopAction_ShortVersion() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + ClientResult response = client.TopAction(DateTimeOffset.Parse(""), null); + + JsonElement result = JsonDocument.Parse(response.GetRawResponse().ContentStream).RootElement; + Console.WriteLine(result.GetProperty("name").ToString()); + Console.WriteLine(result.GetProperty("requiredUnion").ToString()); + Console.WriteLine(result.GetProperty("requiredLiteralString").ToString()); + Console.WriteLine(result.GetProperty("requiredNullableString").ToString()); + Console.WriteLine(result.GetProperty("requiredLiteralInt").ToString()); + Console.WriteLine(result.GetProperty("requiredLiteralFloat").ToString()); + Console.WriteLine(result.GetProperty("requiredLiteralBool").ToString()); + Console.WriteLine(result.GetProperty("requiredNullableLiteralString").ToString()); + Console.WriteLine(result.GetProperty("requiredBadDescription").ToString()); + Console.WriteLine(result.GetProperty("requiredNullableList").ToString()); + Console.WriteLine(result.GetProperty("propertyWithSpecialDocs").ToString()); + } + + /// This sample shows how to call TopActionAsync and parse the result. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public async Task Example_SampleTypeSpec_TopAction_ShortVersion_Async() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + ClientResult response = await client.TopActionAsync(DateTimeOffset.Parse(""), null).ConfigureAwait(false); + + JsonElement result = JsonDocument.Parse(response.GetRawResponse().ContentStream).RootElement; + Console.WriteLine(result.GetProperty("name").ToString()); + Console.WriteLine(result.GetProperty("requiredUnion").ToString()); + Console.WriteLine(result.GetProperty("requiredLiteralString").ToString()); + Console.WriteLine(result.GetProperty("requiredNullableString").ToString()); + Console.WriteLine(result.GetProperty("requiredLiteralInt").ToString()); + Console.WriteLine(result.GetProperty("requiredLiteralFloat").ToString()); + Console.WriteLine(result.GetProperty("requiredLiteralBool").ToString()); + Console.WriteLine(result.GetProperty("requiredNullableLiteralString").ToString()); + Console.WriteLine(result.GetProperty("requiredBadDescription").ToString()); + Console.WriteLine(result.GetProperty("requiredNullableList").ToString()); + Console.WriteLine(result.GetProperty("propertyWithSpecialDocs").ToString()); + } + + /// This sample shows how to call TopAction. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public void Example_SampleTypeSpec_TopAction_ShortVersion_Convenience() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + ClientResult response = client.TopAction(DateTimeOffset.Parse("")); + + } + + /// This sample shows how to call TopActionAsync. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public async Task Example_SampleTypeSpec_TopAction_ShortVersion_Convenience_Async() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + ClientResult response = await client.TopActionAsync(DateTimeOffset.Parse("")).ConfigureAwait(false); + + } + + /// This sample shows how to call TopAction with all parameters and parse the result. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public void Example_SampleTypeSpec_TopAction_AllParameters() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + ClientResult response = client.TopAction(DateTimeOffset.Parse(""), null); + + JsonElement result = JsonDocument.Parse(response.GetRawResponse().ContentStream).RootElement; + Console.WriteLine(result.GetProperty("name").ToString()); + Console.WriteLine(result.GetProperty("requiredUnion").ToString()); + Console.WriteLine(result.GetProperty("requiredLiteralString").ToString()); + Console.WriteLine(result.GetProperty("requiredNullableString").ToString()); + Console.WriteLine(result.GetProperty("optionalNullableString").ToString()); + Console.WriteLine(result.GetProperty("requiredLiteralInt").ToString()); + Console.WriteLine(result.GetProperty("requiredLiteralFloat").ToString()); + Console.WriteLine(result.GetProperty("requiredLiteralBool").ToString()); + Console.WriteLine(result.GetProperty("optionalLiteralString").ToString()); + Console.WriteLine(result.GetProperty("requiredNullableLiteralString").ToString()); + Console.WriteLine(result.GetProperty("optionalLiteralInt").ToString()); + Console.WriteLine(result.GetProperty("optionalLiteralFloat").ToString()); + Console.WriteLine(result.GetProperty("optionalLiteralBool").ToString()); + Console.WriteLine(result.GetProperty("requiredBadDescription").ToString()); + Console.WriteLine(result.GetProperty("optionalNullableList").ToString()); + Console.WriteLine(result.GetProperty("requiredNullableList").ToString()); + Console.WriteLine(result.GetProperty("propertyWithSpecialDocs").ToString()); + } + + /// This sample shows how to call TopActionAsync with all parameters and parse the result. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public async Task Example_SampleTypeSpec_TopAction_AllParameters_Async() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + ClientResult response = await client.TopActionAsync(DateTimeOffset.Parse(""), null).ConfigureAwait(false); + + JsonElement result = JsonDocument.Parse(response.GetRawResponse().ContentStream).RootElement; + Console.WriteLine(result.GetProperty("name").ToString()); + Console.WriteLine(result.GetProperty("requiredUnion").ToString()); + Console.WriteLine(result.GetProperty("requiredLiteralString").ToString()); + Console.WriteLine(result.GetProperty("requiredNullableString").ToString()); + Console.WriteLine(result.GetProperty("optionalNullableString").ToString()); + Console.WriteLine(result.GetProperty("requiredLiteralInt").ToString()); + Console.WriteLine(result.GetProperty("requiredLiteralFloat").ToString()); + Console.WriteLine(result.GetProperty("requiredLiteralBool").ToString()); + Console.WriteLine(result.GetProperty("optionalLiteralString").ToString()); + Console.WriteLine(result.GetProperty("requiredNullableLiteralString").ToString()); + Console.WriteLine(result.GetProperty("optionalLiteralInt").ToString()); + Console.WriteLine(result.GetProperty("optionalLiteralFloat").ToString()); + Console.WriteLine(result.GetProperty("optionalLiteralBool").ToString()); + Console.WriteLine(result.GetProperty("requiredBadDescription").ToString()); + Console.WriteLine(result.GetProperty("optionalNullableList").ToString()); + Console.WriteLine(result.GetProperty("requiredNullableList").ToString()); + Console.WriteLine(result.GetProperty("propertyWithSpecialDocs").ToString()); + } + + /// This sample shows how to call TopAction with all parameters. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public void Example_SampleTypeSpec_TopAction_AllParameters_Convenience() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + ClientResult response = client.TopAction(DateTimeOffset.Parse("")); + + } + + /// This sample shows how to call TopActionAsync with all parameters. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public async Task Example_SampleTypeSpec_TopAction_AllParameters_Convenience_Async() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + ClientResult response = await client.TopActionAsync(DateTimeOffset.Parse("")).ConfigureAwait(false); + + } + + /// This sample shows how to call TopAction2 and parse the result. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public void Example_SampleTypeSpec_TopAction2_ShortVersion() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + ClientResult response = client.TopAction2(); + + JsonElement result = JsonDocument.Parse(response.GetRawResponse().ContentStream).RootElement; + Console.WriteLine(result.GetProperty("name").ToString()); + Console.WriteLine(result.GetProperty("requiredUnion").ToString()); + Console.WriteLine(result.GetProperty("requiredLiteralString").ToString()); + Console.WriteLine(result.GetProperty("requiredNullableString").ToString()); + Console.WriteLine(result.GetProperty("requiredLiteralInt").ToString()); + Console.WriteLine(result.GetProperty("requiredLiteralFloat").ToString()); + Console.WriteLine(result.GetProperty("requiredLiteralBool").ToString()); + Console.WriteLine(result.GetProperty("requiredNullableLiteralString").ToString()); + Console.WriteLine(result.GetProperty("requiredBadDescription").ToString()); + Console.WriteLine(result.GetProperty("requiredNullableList").ToString()); + Console.WriteLine(result.GetProperty("propertyWithSpecialDocs").ToString()); + } + + /// This sample shows how to call TopAction2Async and parse the result. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public async Task Example_SampleTypeSpec_TopAction2_ShortVersion_Async() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + ClientResult response = await client.TopAction2Async().ConfigureAwait(false); + + JsonElement result = JsonDocument.Parse(response.GetRawResponse().ContentStream).RootElement; + Console.WriteLine(result.GetProperty("name").ToString()); + Console.WriteLine(result.GetProperty("requiredUnion").ToString()); + Console.WriteLine(result.GetProperty("requiredLiteralString").ToString()); + Console.WriteLine(result.GetProperty("requiredNullableString").ToString()); + Console.WriteLine(result.GetProperty("requiredLiteralInt").ToString()); + Console.WriteLine(result.GetProperty("requiredLiteralFloat").ToString()); + Console.WriteLine(result.GetProperty("requiredLiteralBool").ToString()); + Console.WriteLine(result.GetProperty("requiredNullableLiteralString").ToString()); + Console.WriteLine(result.GetProperty("requiredBadDescription").ToString()); + Console.WriteLine(result.GetProperty("requiredNullableList").ToString()); + Console.WriteLine(result.GetProperty("propertyWithSpecialDocs").ToString()); + } + + /// This sample shows how to call TopAction2 with all request content and parse the result. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public void Example_SampleTypeSpec_TopAction2_AllParameters() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + ClientResult response = client.TopAction2(); + + JsonElement result = JsonDocument.Parse(response.GetRawResponse().ContentStream).RootElement; + Console.WriteLine(result.GetProperty("name").ToString()); + Console.WriteLine(result.GetProperty("requiredUnion").ToString()); + Console.WriteLine(result.GetProperty("requiredLiteralString").ToString()); + Console.WriteLine(result.GetProperty("requiredNullableString").ToString()); + Console.WriteLine(result.GetProperty("optionalNullableString").ToString()); + Console.WriteLine(result.GetProperty("requiredLiteralInt").ToString()); + Console.WriteLine(result.GetProperty("requiredLiteralFloat").ToString()); + Console.WriteLine(result.GetProperty("requiredLiteralBool").ToString()); + Console.WriteLine(result.GetProperty("optionalLiteralString").ToString()); + Console.WriteLine(result.GetProperty("requiredNullableLiteralString").ToString()); + Console.WriteLine(result.GetProperty("optionalLiteralInt").ToString()); + Console.WriteLine(result.GetProperty("optionalLiteralFloat").ToString()); + Console.WriteLine(result.GetProperty("optionalLiteralBool").ToString()); + Console.WriteLine(result.GetProperty("requiredBadDescription").ToString()); + Console.WriteLine(result.GetProperty("optionalNullableList").ToString()); + Console.WriteLine(result.GetProperty("requiredNullableList").ToString()); + Console.WriteLine(result.GetProperty("propertyWithSpecialDocs").ToString()); + } + + /// This sample shows how to call TopAction2Async with all request content and parse the result. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public async Task Example_SampleTypeSpec_TopAction2_AllParameters_Async() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + ClientResult response = await client.TopAction2Async().ConfigureAwait(false); + + JsonElement result = JsonDocument.Parse(response.GetRawResponse().ContentStream).RootElement; + Console.WriteLine(result.GetProperty("name").ToString()); + Console.WriteLine(result.GetProperty("requiredUnion").ToString()); + Console.WriteLine(result.GetProperty("requiredLiteralString").ToString()); + Console.WriteLine(result.GetProperty("requiredNullableString").ToString()); + Console.WriteLine(result.GetProperty("optionalNullableString").ToString()); + Console.WriteLine(result.GetProperty("requiredLiteralInt").ToString()); + Console.WriteLine(result.GetProperty("requiredLiteralFloat").ToString()); + Console.WriteLine(result.GetProperty("requiredLiteralBool").ToString()); + Console.WriteLine(result.GetProperty("optionalLiteralString").ToString()); + Console.WriteLine(result.GetProperty("requiredNullableLiteralString").ToString()); + Console.WriteLine(result.GetProperty("optionalLiteralInt").ToString()); + Console.WriteLine(result.GetProperty("optionalLiteralFloat").ToString()); + Console.WriteLine(result.GetProperty("optionalLiteralBool").ToString()); + Console.WriteLine(result.GetProperty("requiredBadDescription").ToString()); + Console.WriteLine(result.GetProperty("optionalNullableList").ToString()); + Console.WriteLine(result.GetProperty("requiredNullableList").ToString()); + Console.WriteLine(result.GetProperty("propertyWithSpecialDocs").ToString()); + } + + /// This sample shows how to call PatchAction and parse the result. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public void Example_SampleTypeSpec_PatchAction_ShortVersion() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + using BinaryContent content = BinaryContent.Create(BinaryData.FromObjectAsJson(new + { + name = "", + requiredUnion = "", + requiredLiteralString = "accept", + requiredNullableString = "", + requiredLiteralInt = 123, + requiredLiteralFloat = 1.23F, + requiredLiteralBool = false, + requiredNullableLiteralString = "someValue", + requiredBadDescription = "", + requiredNullableList = new object[] { 0 }, + propertyWithSpecialDocs = "" + })); + ClientResult response = client.PatchAction(content); + + JsonElement result = JsonDocument.Parse(response.GetRawResponse().ContentStream).RootElement; + Console.WriteLine(result.GetProperty("name").ToString()); + Console.WriteLine(result.GetProperty("requiredUnion").ToString()); + Console.WriteLine(result.GetProperty("requiredLiteralString").ToString()); + Console.WriteLine(result.GetProperty("requiredNullableString").ToString()); + Console.WriteLine(result.GetProperty("requiredLiteralInt").ToString()); + Console.WriteLine(result.GetProperty("requiredLiteralFloat").ToString()); + Console.WriteLine(result.GetProperty("requiredLiteralBool").ToString()); + Console.WriteLine(result.GetProperty("requiredNullableLiteralString").ToString()); + Console.WriteLine(result.GetProperty("requiredBadDescription").ToString()); + Console.WriteLine(result.GetProperty("requiredNullableList").ToString()); + Console.WriteLine(result.GetProperty("propertyWithSpecialDocs").ToString()); + } + + /// This sample shows how to call PatchActionAsync and parse the result. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public async Task Example_SampleTypeSpec_PatchAction_ShortVersion_Async() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + using BinaryContent content = BinaryContent.Create(BinaryData.FromObjectAsJson(new + { + name = "", + requiredUnion = "", + requiredLiteralString = "accept", + requiredNullableString = "", + requiredLiteralInt = 123, + requiredLiteralFloat = 1.23F, + requiredLiteralBool = false, + requiredNullableLiteralString = "someValue", + requiredBadDescription = "", + requiredNullableList = new object[] { 0 }, + propertyWithSpecialDocs = "" + })); + ClientResult response = await client.PatchActionAsync(content).ConfigureAwait(false); + + JsonElement result = JsonDocument.Parse(response.GetRawResponse().ContentStream).RootElement; + Console.WriteLine(result.GetProperty("name").ToString()); + Console.WriteLine(result.GetProperty("requiredUnion").ToString()); + Console.WriteLine(result.GetProperty("requiredLiteralString").ToString()); + Console.WriteLine(result.GetProperty("requiredNullableString").ToString()); + Console.WriteLine(result.GetProperty("requiredLiteralInt").ToString()); + Console.WriteLine(result.GetProperty("requiredLiteralFloat").ToString()); + Console.WriteLine(result.GetProperty("requiredLiteralBool").ToString()); + Console.WriteLine(result.GetProperty("requiredNullableLiteralString").ToString()); + Console.WriteLine(result.GetProperty("requiredBadDescription").ToString()); + Console.WriteLine(result.GetProperty("requiredNullableList").ToString()); + Console.WriteLine(result.GetProperty("propertyWithSpecialDocs").ToString()); + } + + /// This sample shows how to call PatchAction with all request content and parse the result. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public void Example_SampleTypeSpec_PatchAction_AllParameters() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + using BinaryContent content = BinaryContent.Create(BinaryData.FromObjectAsJson(new + { + name = "", + requiredUnion = "", + requiredLiteralString = "accept", + requiredNullableString = "", + optionalNullableString = "", + requiredLiteralInt = 123, + requiredLiteralFloat = 1.23F, + requiredLiteralBool = false, + optionalLiteralString = "reject", + requiredNullableLiteralString = "someValue", + optionalLiteralInt = 456, + optionalLiteralFloat = 4.56F, + optionalLiteralBool = true, + requiredBadDescription = "", + optionalNullableList = new object[] { 0 }, + requiredNullableList = new object[] { 0 }, + propertyWithSpecialDocs = "" + })); + ClientResult response = client.PatchAction(content); + + JsonElement result = JsonDocument.Parse(response.GetRawResponse().ContentStream).RootElement; + Console.WriteLine(result.GetProperty("name").ToString()); + Console.WriteLine(result.GetProperty("requiredUnion").ToString()); + Console.WriteLine(result.GetProperty("requiredLiteralString").ToString()); + Console.WriteLine(result.GetProperty("requiredNullableString").ToString()); + Console.WriteLine(result.GetProperty("optionalNullableString").ToString()); + Console.WriteLine(result.GetProperty("requiredLiteralInt").ToString()); + Console.WriteLine(result.GetProperty("requiredLiteralFloat").ToString()); + Console.WriteLine(result.GetProperty("requiredLiteralBool").ToString()); + Console.WriteLine(result.GetProperty("optionalLiteralString").ToString()); + Console.WriteLine(result.GetProperty("requiredNullableLiteralString").ToString()); + Console.WriteLine(result.GetProperty("optionalLiteralInt").ToString()); + Console.WriteLine(result.GetProperty("optionalLiteralFloat").ToString()); + Console.WriteLine(result.GetProperty("optionalLiteralBool").ToString()); + Console.WriteLine(result.GetProperty("requiredBadDescription").ToString()); + Console.WriteLine(result.GetProperty("optionalNullableList").ToString()); + Console.WriteLine(result.GetProperty("requiredNullableList").ToString()); + Console.WriteLine(result.GetProperty("propertyWithSpecialDocs").ToString()); + } + + /// This sample shows how to call PatchActionAsync with all request content and parse the result. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public async Task Example_SampleTypeSpec_PatchAction_AllParameters_Async() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + using BinaryContent content = BinaryContent.Create(BinaryData.FromObjectAsJson(new + { + name = "", + requiredUnion = "", + requiredLiteralString = "accept", + requiredNullableString = "", + optionalNullableString = "", + requiredLiteralInt = 123, + requiredLiteralFloat = 1.23F, + requiredLiteralBool = false, + optionalLiteralString = "reject", + requiredNullableLiteralString = "someValue", + optionalLiteralInt = 456, + optionalLiteralFloat = 4.56F, + optionalLiteralBool = true, + requiredBadDescription = "", + optionalNullableList = new object[] { 0 }, + requiredNullableList = new object[] { 0 }, + propertyWithSpecialDocs = "" + })); + ClientResult response = await client.PatchActionAsync(content).ConfigureAwait(false); + + JsonElement result = JsonDocument.Parse(response.GetRawResponse().ContentStream).RootElement; + Console.WriteLine(result.GetProperty("name").ToString()); + Console.WriteLine(result.GetProperty("requiredUnion").ToString()); + Console.WriteLine(result.GetProperty("requiredLiteralString").ToString()); + Console.WriteLine(result.GetProperty("requiredNullableString").ToString()); + Console.WriteLine(result.GetProperty("optionalNullableString").ToString()); + Console.WriteLine(result.GetProperty("requiredLiteralInt").ToString()); + Console.WriteLine(result.GetProperty("requiredLiteralFloat").ToString()); + Console.WriteLine(result.GetProperty("requiredLiteralBool").ToString()); + Console.WriteLine(result.GetProperty("optionalLiteralString").ToString()); + Console.WriteLine(result.GetProperty("requiredNullableLiteralString").ToString()); + Console.WriteLine(result.GetProperty("optionalLiteralInt").ToString()); + Console.WriteLine(result.GetProperty("optionalLiteralFloat").ToString()); + Console.WriteLine(result.GetProperty("optionalLiteralBool").ToString()); + Console.WriteLine(result.GetProperty("requiredBadDescription").ToString()); + Console.WriteLine(result.GetProperty("optionalNullableList").ToString()); + Console.WriteLine(result.GetProperty("requiredNullableList").ToString()); + Console.WriteLine(result.GetProperty("propertyWithSpecialDocs").ToString()); + } + + /// This sample shows how to call AnonymousBody and parse the result. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public void Example_SampleTypeSpec_AnonymousBody_ShortVersion() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + using BinaryContent content = BinaryContent.Create(BinaryData.FromObjectAsJson(new + { + name = "", + requiredUnion = "", + requiredLiteralString = "accept", + requiredNullableString = "", + requiredLiteralInt = 123, + requiredLiteralFloat = 1.23F, + requiredLiteralBool = false, + requiredNullableLiteralString = "someValue", + requiredBadDescription = "", + requiredNullableList = new object[] { 0 }, + propertyWithSpecialDocs = "" + })); + ClientResult response = client.AnonymousBody(content); + + JsonElement result = JsonDocument.Parse(response.GetRawResponse().ContentStream).RootElement; + Console.WriteLine(result.GetProperty("name").ToString()); + Console.WriteLine(result.GetProperty("requiredUnion").ToString()); + Console.WriteLine(result.GetProperty("requiredLiteralString").ToString()); + Console.WriteLine(result.GetProperty("requiredNullableString").ToString()); + Console.WriteLine(result.GetProperty("requiredLiteralInt").ToString()); + Console.WriteLine(result.GetProperty("requiredLiteralFloat").ToString()); + Console.WriteLine(result.GetProperty("requiredLiteralBool").ToString()); + Console.WriteLine(result.GetProperty("requiredNullableLiteralString").ToString()); + Console.WriteLine(result.GetProperty("requiredBadDescription").ToString()); + Console.WriteLine(result.GetProperty("requiredNullableList").ToString()); + Console.WriteLine(result.GetProperty("propertyWithSpecialDocs").ToString()); + } + + /// This sample shows how to call AnonymousBodyAsync and parse the result. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public async Task Example_SampleTypeSpec_AnonymousBody_ShortVersion_Async() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + using BinaryContent content = BinaryContent.Create(BinaryData.FromObjectAsJson(new + { + name = "", + requiredUnion = "", + requiredLiteralString = "accept", + requiredNullableString = "", + requiredLiteralInt = 123, + requiredLiteralFloat = 1.23F, + requiredLiteralBool = false, + requiredNullableLiteralString = "someValue", + requiredBadDescription = "", + requiredNullableList = new object[] { 0 }, + propertyWithSpecialDocs = "" + })); + ClientResult response = await client.AnonymousBodyAsync(content).ConfigureAwait(false); + + JsonElement result = JsonDocument.Parse(response.GetRawResponse().ContentStream).RootElement; + Console.WriteLine(result.GetProperty("name").ToString()); + Console.WriteLine(result.GetProperty("requiredUnion").ToString()); + Console.WriteLine(result.GetProperty("requiredLiteralString").ToString()); + Console.WriteLine(result.GetProperty("requiredNullableString").ToString()); + Console.WriteLine(result.GetProperty("requiredLiteralInt").ToString()); + Console.WriteLine(result.GetProperty("requiredLiteralFloat").ToString()); + Console.WriteLine(result.GetProperty("requiredLiteralBool").ToString()); + Console.WriteLine(result.GetProperty("requiredNullableLiteralString").ToString()); + Console.WriteLine(result.GetProperty("requiredBadDescription").ToString()); + Console.WriteLine(result.GetProperty("requiredNullableList").ToString()); + Console.WriteLine(result.GetProperty("propertyWithSpecialDocs").ToString()); + } + + /// This sample shows how to call AnonymousBody. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public void Example_SampleTypeSpec_AnonymousBody_ShortVersion_Convenience() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + ClientResult response = client.AnonymousBody(null, null, null, null, null, null, null); + + } + + /// This sample shows how to call AnonymousBodyAsync. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public async Task Example_SampleTypeSpec_AnonymousBody_ShortVersion_Convenience_Async() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + ClientResult response = await client.AnonymousBodyAsync(null, null, null, null, null, null, null).ConfigureAwait(false); + + } + + /// This sample shows how to call AnonymousBody with all request content and parse the result. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public void Example_SampleTypeSpec_AnonymousBody_AllParameters() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + using BinaryContent content = BinaryContent.Create(BinaryData.FromObjectAsJson(new + { + name = "", + requiredUnion = "", + requiredLiteralString = "accept", + requiredNullableString = "", + optionalNullableString = "", + requiredLiteralInt = 123, + requiredLiteralFloat = 1.23F, + requiredLiteralBool = false, + optionalLiteralString = "reject", + requiredNullableLiteralString = "someValue", + optionalLiteralInt = 456, + optionalLiteralFloat = 4.56F, + optionalLiteralBool = true, + requiredBadDescription = "", + optionalNullableList = new object[] { 0 }, + requiredNullableList = new object[] { 0 }, + propertyWithSpecialDocs = "" + })); + ClientResult response = client.AnonymousBody(content); + + JsonElement result = JsonDocument.Parse(response.GetRawResponse().ContentStream).RootElement; + Console.WriteLine(result.GetProperty("name").ToString()); + Console.WriteLine(result.GetProperty("requiredUnion").ToString()); + Console.WriteLine(result.GetProperty("requiredLiteralString").ToString()); + Console.WriteLine(result.GetProperty("requiredNullableString").ToString()); + Console.WriteLine(result.GetProperty("optionalNullableString").ToString()); + Console.WriteLine(result.GetProperty("requiredLiteralInt").ToString()); + Console.WriteLine(result.GetProperty("requiredLiteralFloat").ToString()); + Console.WriteLine(result.GetProperty("requiredLiteralBool").ToString()); + Console.WriteLine(result.GetProperty("optionalLiteralString").ToString()); + Console.WriteLine(result.GetProperty("requiredNullableLiteralString").ToString()); + Console.WriteLine(result.GetProperty("optionalLiteralInt").ToString()); + Console.WriteLine(result.GetProperty("optionalLiteralFloat").ToString()); + Console.WriteLine(result.GetProperty("optionalLiteralBool").ToString()); + Console.WriteLine(result.GetProperty("requiredBadDescription").ToString()); + Console.WriteLine(result.GetProperty("optionalNullableList").ToString()); + Console.WriteLine(result.GetProperty("requiredNullableList").ToString()); + Console.WriteLine(result.GetProperty("propertyWithSpecialDocs").ToString()); + } + + /// This sample shows how to call AnonymousBodyAsync with all request content and parse the result. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public async Task Example_SampleTypeSpec_AnonymousBody_AllParameters_Async() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + using BinaryContent content = BinaryContent.Create(BinaryData.FromObjectAsJson(new + { + name = "", + requiredUnion = "", + requiredLiteralString = "accept", + requiredNullableString = "", + optionalNullableString = "", + requiredLiteralInt = 123, + requiredLiteralFloat = 1.23F, + requiredLiteralBool = false, + optionalLiteralString = "reject", + requiredNullableLiteralString = "someValue", + optionalLiteralInt = 456, + optionalLiteralFloat = 4.56F, + optionalLiteralBool = true, + requiredBadDescription = "", + optionalNullableList = new object[] { 0 }, + requiredNullableList = new object[] { 0 }, + propertyWithSpecialDocs = "" + })); + ClientResult response = await client.AnonymousBodyAsync(content).ConfigureAwait(false); + + JsonElement result = JsonDocument.Parse(response.GetRawResponse().ContentStream).RootElement; + Console.WriteLine(result.GetProperty("name").ToString()); + Console.WriteLine(result.GetProperty("requiredUnion").ToString()); + Console.WriteLine(result.GetProperty("requiredLiteralString").ToString()); + Console.WriteLine(result.GetProperty("requiredNullableString").ToString()); + Console.WriteLine(result.GetProperty("optionalNullableString").ToString()); + Console.WriteLine(result.GetProperty("requiredLiteralInt").ToString()); + Console.WriteLine(result.GetProperty("requiredLiteralFloat").ToString()); + Console.WriteLine(result.GetProperty("requiredLiteralBool").ToString()); + Console.WriteLine(result.GetProperty("optionalLiteralString").ToString()); + Console.WriteLine(result.GetProperty("requiredNullableLiteralString").ToString()); + Console.WriteLine(result.GetProperty("optionalLiteralInt").ToString()); + Console.WriteLine(result.GetProperty("optionalLiteralFloat").ToString()); + Console.WriteLine(result.GetProperty("optionalLiteralBool").ToString()); + Console.WriteLine(result.GetProperty("requiredBadDescription").ToString()); + Console.WriteLine(result.GetProperty("optionalNullableList").ToString()); + Console.WriteLine(result.GetProperty("requiredNullableList").ToString()); + Console.WriteLine(result.GetProperty("propertyWithSpecialDocs").ToString()); + } + + /// This sample shows how to call AnonymousBody with all parameters. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public void Example_SampleTypeSpec_AnonymousBody_AllParameters_Convenience() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + ClientResult response = client.AnonymousBody(null, null, null, null, null, null, null); + + } + + /// This sample shows how to call AnonymousBodyAsync with all parameters. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public async Task Example_SampleTypeSpec_AnonymousBody_AllParameters_Convenience_Async() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + ClientResult response = await client.AnonymousBodyAsync(null, null, null, null, null, null, null).ConfigureAwait(false); + + } + + /// This sample shows how to call FriendlyModel and parse the result. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public void Example_SampleTypeSpec_FriendlyModel_ShortVersion() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + using BinaryContent content = BinaryContent.Create(BinaryData.FromObjectAsJson(new + { + name = "" + })); + ClientResult response = client.FriendlyModel(content); + + JsonElement result = JsonDocument.Parse(response.GetRawResponse().ContentStream).RootElement; + Console.WriteLine(result.GetProperty("name").ToString()); + } + + /// This sample shows how to call FriendlyModelAsync and parse the result. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public async Task Example_SampleTypeSpec_FriendlyModel_ShortVersion_Async() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + using BinaryContent content = BinaryContent.Create(BinaryData.FromObjectAsJson(new + { + name = "" + })); + ClientResult response = await client.FriendlyModelAsync(content).ConfigureAwait(false); + + JsonElement result = JsonDocument.Parse(response.GetRawResponse().ContentStream).RootElement; + Console.WriteLine(result.GetProperty("name").ToString()); + } + + /// This sample shows how to call FriendlyModel. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public void Example_SampleTypeSpec_FriendlyModel_ShortVersion_Convenience() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + ClientResult response = client.FriendlyModel((string)null); + + } + + /// This sample shows how to call FriendlyModelAsync. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public async Task Example_SampleTypeSpec_FriendlyModel_ShortVersion_Convenience_Async() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + ClientResult response = await client.FriendlyModelAsync((string)null).ConfigureAwait(false); + + } + + /// This sample shows how to call FriendlyModel with all request content and parse the result. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public void Example_SampleTypeSpec_FriendlyModel_AllParameters() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + using BinaryContent content = BinaryContent.Create(BinaryData.FromObjectAsJson(new + { + name = "" + })); + ClientResult response = client.FriendlyModel(content); + + JsonElement result = JsonDocument.Parse(response.GetRawResponse().ContentStream).RootElement; + Console.WriteLine(result.GetProperty("name").ToString()); + } + + /// This sample shows how to call FriendlyModelAsync with all request content and parse the result. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public async Task Example_SampleTypeSpec_FriendlyModel_AllParameters_Async() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + using BinaryContent content = BinaryContent.Create(BinaryData.FromObjectAsJson(new + { + name = "" + })); + ClientResult response = await client.FriendlyModelAsync(content).ConfigureAwait(false); + + JsonElement result = JsonDocument.Parse(response.GetRawResponse().ContentStream).RootElement; + Console.WriteLine(result.GetProperty("name").ToString()); + } + + /// This sample shows how to call FriendlyModel with all parameters. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public void Example_SampleTypeSpec_FriendlyModel_AllParameters_Convenience() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + ClientResult response = client.FriendlyModel((string)null); + + } + + /// This sample shows how to call FriendlyModelAsync with all parameters. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public async Task Example_SampleTypeSpec_FriendlyModel_AllParameters_Convenience_Async() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + ClientResult response = await client.FriendlyModelAsync((string)null).ConfigureAwait(false); + + } + + /// This sample shows how to call AddTimeHeader. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public void Example_SampleTypeSpec_AddTimeHeader_ShortVersion() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + ClientResult response = client.AddTimeHeader(null); + + } + + /// This sample shows how to call AddTimeHeaderAsync. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public async Task Example_SampleTypeSpec_AddTimeHeader_ShortVersion_Async() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + ClientResult response = await client.AddTimeHeaderAsync(null).ConfigureAwait(false); + + } + + /// This sample shows how to call AddTimeHeader. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public void Example_SampleTypeSpec_AddTimeHeader_ShortVersion_Convenience() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + ClientResult response = client.AddTimeHeader(); + + } + + /// This sample shows how to call AddTimeHeaderAsync. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public async Task Example_SampleTypeSpec_AddTimeHeader_ShortVersion_Convenience_Async() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + ClientResult response = await client.AddTimeHeaderAsync().ConfigureAwait(false); + + } + + /// This sample shows how to call AddTimeHeader with all request content. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public void Example_SampleTypeSpec_AddTimeHeader_AllParameters() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + ClientResult response = client.AddTimeHeader(null); + + } + + /// This sample shows how to call AddTimeHeaderAsync with all request content. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public async Task Example_SampleTypeSpec_AddTimeHeader_AllParameters_Async() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + ClientResult response = await client.AddTimeHeaderAsync(null).ConfigureAwait(false); + + } + + /// This sample shows how to call AddTimeHeader with all parameters. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public void Example_SampleTypeSpec_AddTimeHeader_AllParameters_Convenience() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + ClientResult response = client.AddTimeHeader(); + + } + + /// This sample shows how to call AddTimeHeaderAsync with all parameters. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public async Task Example_SampleTypeSpec_AddTimeHeader_AllParameters_Convenience_Async() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + ClientResult response = await client.AddTimeHeaderAsync().ConfigureAwait(false); + + } + + /// This sample shows how to call ProjectedNameModel and parse the result. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public void Example_SampleTypeSpec_ProjectedNameModel_ShortVersion() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + using BinaryContent content = BinaryContent.Create(BinaryData.FromObjectAsJson(new + { + otherName = "" + })); + ClientResult response = client.ProjectedNameModel(content); + + JsonElement result = JsonDocument.Parse(response.GetRawResponse().ContentStream).RootElement; + Console.WriteLine(result.GetProperty("otherName").ToString()); + } + + /// This sample shows how to call ProjectedNameModelAsync and parse the result. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public async Task Example_SampleTypeSpec_ProjectedNameModel_ShortVersion_Async() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + using BinaryContent content = BinaryContent.Create(BinaryData.FromObjectAsJson(new + { + otherName = "" + })); + ClientResult response = await client.ProjectedNameModelAsync(content).ConfigureAwait(false); + + JsonElement result = JsonDocument.Parse(response.GetRawResponse().ContentStream).RootElement; + Console.WriteLine(result.GetProperty("otherName").ToString()); + } + + /// This sample shows how to call ProjectedNameModel. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public void Example_SampleTypeSpec_ProjectedNameModel_ShortVersion_Convenience() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + ClientResult response = client.ProjectedNameModel((string)null); + + } + + /// This sample shows how to call ProjectedNameModelAsync. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public async Task Example_SampleTypeSpec_ProjectedNameModel_ShortVersion_Convenience_Async() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + ClientResult response = await client.ProjectedNameModelAsync((string)null).ConfigureAwait(false); + + } + + /// This sample shows how to call ProjectedNameModel with all request content and parse the result. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public void Example_SampleTypeSpec_ProjectedNameModel_AllParameters() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + using BinaryContent content = BinaryContent.Create(BinaryData.FromObjectAsJson(new + { + otherName = "" + })); + ClientResult response = client.ProjectedNameModel(content); + + JsonElement result = JsonDocument.Parse(response.GetRawResponse().ContentStream).RootElement; + Console.WriteLine(result.GetProperty("otherName").ToString()); + } + + /// This sample shows how to call ProjectedNameModelAsync with all request content and parse the result. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public async Task Example_SampleTypeSpec_ProjectedNameModel_AllParameters_Async() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + using BinaryContent content = BinaryContent.Create(BinaryData.FromObjectAsJson(new + { + otherName = "" + })); + ClientResult response = await client.ProjectedNameModelAsync(content).ConfigureAwait(false); + + JsonElement result = JsonDocument.Parse(response.GetRawResponse().ContentStream).RootElement; + Console.WriteLine(result.GetProperty("otherName").ToString()); + } + + /// This sample shows how to call ProjectedNameModel with all parameters. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public void Example_SampleTypeSpec_ProjectedNameModel_AllParameters_Convenience() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + ClientResult response = client.ProjectedNameModel((string)null); + + } + + /// This sample shows how to call ProjectedNameModelAsync with all parameters. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public async Task Example_SampleTypeSpec_ProjectedNameModel_AllParameters_Convenience_Async() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + ClientResult response = await client.ProjectedNameModelAsync((string)null).ConfigureAwait(false); + + } + + /// This sample shows how to call ReturnsAnonymousModel and parse the result. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public void Example_SampleTypeSpec_ReturnsAnonymousModel_ShortVersion() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + ClientResult response = client.ReturnsAnonymousModel(null); + + JsonElement result = JsonDocument.Parse(response.GetRawResponse().ContentStream).RootElement; + } + + /// This sample shows how to call ReturnsAnonymousModelAsync and parse the result. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public async Task Example_SampleTypeSpec_ReturnsAnonymousModel_ShortVersion_Async() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + ClientResult response = await client.ReturnsAnonymousModelAsync(null).ConfigureAwait(false); + + JsonElement result = JsonDocument.Parse(response.GetRawResponse().ContentStream).RootElement; + } + + /// This sample shows how to call ReturnsAnonymousModel. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public void Example_SampleTypeSpec_ReturnsAnonymousModel_ShortVersion_Convenience() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + ClientResult response = client.ReturnsAnonymousModel(); + + } + + /// This sample shows how to call ReturnsAnonymousModelAsync. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public async Task Example_SampleTypeSpec_ReturnsAnonymousModel_ShortVersion_Convenience_Async() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + ClientResult response = await client.ReturnsAnonymousModelAsync().ConfigureAwait(false); + + } + + /// This sample shows how to call ReturnsAnonymousModel with all request content and parse the result. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public void Example_SampleTypeSpec_ReturnsAnonymousModel_AllParameters() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + ClientResult response = client.ReturnsAnonymousModel(null); + + JsonElement result = JsonDocument.Parse(response.GetRawResponse().ContentStream).RootElement; + } + + /// This sample shows how to call ReturnsAnonymousModelAsync with all request content and parse the result. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public async Task Example_SampleTypeSpec_ReturnsAnonymousModel_AllParameters_Async() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + ClientResult response = await client.ReturnsAnonymousModelAsync(null).ConfigureAwait(false); + + JsonElement result = JsonDocument.Parse(response.GetRawResponse().ContentStream).RootElement; + } + + /// This sample shows how to call ReturnsAnonymousModel with all parameters. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public void Example_SampleTypeSpec_ReturnsAnonymousModel_AllParameters_Convenience() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + ClientResult response = client.ReturnsAnonymousModel(); + + } + + /// This sample shows how to call ReturnsAnonymousModelAsync with all parameters. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public async Task Example_SampleTypeSpec_ReturnsAnonymousModel_AllParameters_Convenience_Async() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + ClientResult response = await client.ReturnsAnonymousModelAsync().ConfigureAwait(false); + + } + + /// This sample shows how to call GetUnknownValue and parse the result. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public void Example_SampleTypeSpec_GetUnknownValue_ShortVersion() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + ClientResult response = client.GetUnknownValue(null); + + JsonElement result = JsonDocument.Parse(response.GetRawResponse().ContentStream).RootElement; + Console.WriteLine(result.ToString()); + } + + /// This sample shows how to call GetUnknownValueAsync and parse the result. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public async Task Example_SampleTypeSpec_GetUnknownValue_ShortVersion_Async() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + ClientResult response = await client.GetUnknownValueAsync(null).ConfigureAwait(false); + + JsonElement result = JsonDocument.Parse(response.GetRawResponse().ContentStream).RootElement; + Console.WriteLine(result.ToString()); + } + + /// This sample shows how to call GetUnknownValue. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public void Example_SampleTypeSpec_GetUnknownValue_ShortVersion_Convenience() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + ClientResult response = client.GetUnknownValue(); + + } + + /// This sample shows how to call GetUnknownValueAsync. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public async Task Example_SampleTypeSpec_GetUnknownValue_ShortVersion_Convenience_Async() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + ClientResult response = await client.GetUnknownValueAsync().ConfigureAwait(false); + + } + + /// This sample shows how to call GetUnknownValue with all request content and parse the result. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public void Example_SampleTypeSpec_GetUnknownValue_AllParameters() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + ClientResult response = client.GetUnknownValue(null); + + JsonElement result = JsonDocument.Parse(response.GetRawResponse().ContentStream).RootElement; + Console.WriteLine(result.ToString()); + } + + /// This sample shows how to call GetUnknownValueAsync with all request content and parse the result. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public async Task Example_SampleTypeSpec_GetUnknownValue_AllParameters_Async() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + ClientResult response = await client.GetUnknownValueAsync(null).ConfigureAwait(false); + + JsonElement result = JsonDocument.Parse(response.GetRawResponse().ContentStream).RootElement; + Console.WriteLine(result.ToString()); + } + + /// This sample shows how to call GetUnknownValue with all parameters. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public void Example_SampleTypeSpec_GetUnknownValue_AllParameters_Convenience() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + ClientResult response = client.GetUnknownValue(); + + } + + /// This sample shows how to call GetUnknownValueAsync with all parameters. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public async Task Example_SampleTypeSpec_GetUnknownValue_AllParameters_Convenience_Async() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + ClientResult response = await client.GetUnknownValueAsync().ConfigureAwait(false); + + } + + /// This sample shows how to call InternalProtocol and parse the result. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public void Example_SampleTypeSpec_InternalProtocol_ShortVersion() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + using BinaryContent content = BinaryContent.Create(BinaryData.FromObjectAsJson(new + { + name = "", + requiredUnion = "", + requiredLiteralString = "accept", + requiredNullableString = "", + requiredLiteralInt = 123, + requiredLiteralFloat = 1.23F, + requiredLiteralBool = false, + requiredNullableLiteralString = "someValue", + requiredBadDescription = "", + requiredNullableList = new object[] { 0 }, + propertyWithSpecialDocs = "" + })); + ClientResult response = client.InternalProtocol(content); + + JsonElement result = JsonDocument.Parse(response.GetRawResponse().ContentStream).RootElement; + Console.WriteLine(result.GetProperty("name").ToString()); + Console.WriteLine(result.GetProperty("requiredUnion").ToString()); + Console.WriteLine(result.GetProperty("requiredLiteralString").ToString()); + Console.WriteLine(result.GetProperty("requiredNullableString").ToString()); + Console.WriteLine(result.GetProperty("requiredLiteralInt").ToString()); + Console.WriteLine(result.GetProperty("requiredLiteralFloat").ToString()); + Console.WriteLine(result.GetProperty("requiredLiteralBool").ToString()); + Console.WriteLine(result.GetProperty("requiredNullableLiteralString").ToString()); + Console.WriteLine(result.GetProperty("requiredBadDescription").ToString()); + Console.WriteLine(result.GetProperty("requiredNullableList").ToString()); + Console.WriteLine(result.GetProperty("propertyWithSpecialDocs").ToString()); + } + + /// This sample shows how to call InternalProtocolAsync and parse the result. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public async Task Example_SampleTypeSpec_InternalProtocol_ShortVersion_Async() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + using BinaryContent content = BinaryContent.Create(BinaryData.FromObjectAsJson(new + { + name = "", + requiredUnion = "", + requiredLiteralString = "accept", + requiredNullableString = "", + requiredLiteralInt = 123, + requiredLiteralFloat = 1.23F, + requiredLiteralBool = false, + requiredNullableLiteralString = "someValue", + requiredBadDescription = "", + requiredNullableList = new object[] { 0 }, + propertyWithSpecialDocs = "" + })); + ClientResult response = await client.InternalProtocolAsync(content).ConfigureAwait(false); + + JsonElement result = JsonDocument.Parse(response.GetRawResponse().ContentStream).RootElement; + Console.WriteLine(result.GetProperty("name").ToString()); + Console.WriteLine(result.GetProperty("requiredUnion").ToString()); + Console.WriteLine(result.GetProperty("requiredLiteralString").ToString()); + Console.WriteLine(result.GetProperty("requiredNullableString").ToString()); + Console.WriteLine(result.GetProperty("requiredLiteralInt").ToString()); + Console.WriteLine(result.GetProperty("requiredLiteralFloat").ToString()); + Console.WriteLine(result.GetProperty("requiredLiteralBool").ToString()); + Console.WriteLine(result.GetProperty("requiredNullableLiteralString").ToString()); + Console.WriteLine(result.GetProperty("requiredBadDescription").ToString()); + Console.WriteLine(result.GetProperty("requiredNullableList").ToString()); + Console.WriteLine(result.GetProperty("propertyWithSpecialDocs").ToString()); + } + + /// This sample shows how to call InternalProtocol. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public void Example_SampleTypeSpec_InternalProtocol_ShortVersion_Convenience() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + Thing body = new Thing( + "", + BinaryData.FromObjectAsJson(""), + "", + ThingRequiredNullableLiteralString1.SomeValue, + "", + new int[] { 0 }, + ""); + ClientResult response = client.InternalProtocol(body); + + } + + /// This sample shows how to call InternalProtocolAsync. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public async Task Example_SampleTypeSpec_InternalProtocol_ShortVersion_Convenience_Async() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + Thing body = new Thing( + "", + BinaryData.FromObjectAsJson(""), + "", + ThingRequiredNullableLiteralString1.SomeValue, + "", + new int[] { 0 }, + ""); + ClientResult response = await client.InternalProtocolAsync(body).ConfigureAwait(false); + + } + + /// This sample shows how to call InternalProtocol with all request content and parse the result. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public void Example_SampleTypeSpec_InternalProtocol_AllParameters() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + using BinaryContent content = BinaryContent.Create(BinaryData.FromObjectAsJson(new + { + name = "", + requiredUnion = "", + requiredLiteralString = "accept", + requiredNullableString = "", + optionalNullableString = "", + requiredLiteralInt = 123, + requiredLiteralFloat = 1.23F, + requiredLiteralBool = false, + optionalLiteralString = "reject", + requiredNullableLiteralString = "someValue", + optionalLiteralInt = 456, + optionalLiteralFloat = 4.56F, + optionalLiteralBool = true, + requiredBadDescription = "", + optionalNullableList = new object[] { 0 }, + requiredNullableList = new object[] { 0 }, + propertyWithSpecialDocs = "" + })); + ClientResult response = client.InternalProtocol(content); + + JsonElement result = JsonDocument.Parse(response.GetRawResponse().ContentStream).RootElement; + Console.WriteLine(result.GetProperty("name").ToString()); + Console.WriteLine(result.GetProperty("requiredUnion").ToString()); + Console.WriteLine(result.GetProperty("requiredLiteralString").ToString()); + Console.WriteLine(result.GetProperty("requiredNullableString").ToString()); + Console.WriteLine(result.GetProperty("optionalNullableString").ToString()); + Console.WriteLine(result.GetProperty("requiredLiteralInt").ToString()); + Console.WriteLine(result.GetProperty("requiredLiteralFloat").ToString()); + Console.WriteLine(result.GetProperty("requiredLiteralBool").ToString()); + Console.WriteLine(result.GetProperty("optionalLiteralString").ToString()); + Console.WriteLine(result.GetProperty("requiredNullableLiteralString").ToString()); + Console.WriteLine(result.GetProperty("optionalLiteralInt").ToString()); + Console.WriteLine(result.GetProperty("optionalLiteralFloat").ToString()); + Console.WriteLine(result.GetProperty("optionalLiteralBool").ToString()); + Console.WriteLine(result.GetProperty("requiredBadDescription").ToString()); + Console.WriteLine(result.GetProperty("optionalNullableList").ToString()); + Console.WriteLine(result.GetProperty("requiredNullableList").ToString()); + Console.WriteLine(result.GetProperty("propertyWithSpecialDocs").ToString()); + } + + /// This sample shows how to call InternalProtocolAsync with all request content and parse the result. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public async Task Example_SampleTypeSpec_InternalProtocol_AllParameters_Async() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + using BinaryContent content = BinaryContent.Create(BinaryData.FromObjectAsJson(new + { + name = "", + requiredUnion = "", + requiredLiteralString = "accept", + requiredNullableString = "", + optionalNullableString = "", + requiredLiteralInt = 123, + requiredLiteralFloat = 1.23F, + requiredLiteralBool = false, + optionalLiteralString = "reject", + requiredNullableLiteralString = "someValue", + optionalLiteralInt = 456, + optionalLiteralFloat = 4.56F, + optionalLiteralBool = true, + requiredBadDescription = "", + optionalNullableList = new object[] { 0 }, + requiredNullableList = new object[] { 0 }, + propertyWithSpecialDocs = "" + })); + ClientResult response = await client.InternalProtocolAsync(content).ConfigureAwait(false); + + JsonElement result = JsonDocument.Parse(response.GetRawResponse().ContentStream).RootElement; + Console.WriteLine(result.GetProperty("name").ToString()); + Console.WriteLine(result.GetProperty("requiredUnion").ToString()); + Console.WriteLine(result.GetProperty("requiredLiteralString").ToString()); + Console.WriteLine(result.GetProperty("requiredNullableString").ToString()); + Console.WriteLine(result.GetProperty("optionalNullableString").ToString()); + Console.WriteLine(result.GetProperty("requiredLiteralInt").ToString()); + Console.WriteLine(result.GetProperty("requiredLiteralFloat").ToString()); + Console.WriteLine(result.GetProperty("requiredLiteralBool").ToString()); + Console.WriteLine(result.GetProperty("optionalLiteralString").ToString()); + Console.WriteLine(result.GetProperty("requiredNullableLiteralString").ToString()); + Console.WriteLine(result.GetProperty("optionalLiteralInt").ToString()); + Console.WriteLine(result.GetProperty("optionalLiteralFloat").ToString()); + Console.WriteLine(result.GetProperty("optionalLiteralBool").ToString()); + Console.WriteLine(result.GetProperty("requiredBadDescription").ToString()); + Console.WriteLine(result.GetProperty("optionalNullableList").ToString()); + Console.WriteLine(result.GetProperty("requiredNullableList").ToString()); + Console.WriteLine(result.GetProperty("propertyWithSpecialDocs").ToString()); + } + + /// This sample shows how to call InternalProtocol with all parameters. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public void Example_SampleTypeSpec_InternalProtocol_AllParameters_Convenience() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + Thing body = new Thing( + "", + BinaryData.FromObjectAsJson(""), + "", + ThingRequiredNullableLiteralString1.SomeValue, + "", + new int[] { 0 }, + ""); + ClientResult response = client.InternalProtocol(body); + + } + + /// This sample shows how to call InternalProtocolAsync with all parameters. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public async Task Example_SampleTypeSpec_InternalProtocol_AllParameters_Convenience_Async() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + Thing body = new Thing( + "", + BinaryData.FromObjectAsJson(""), + "", + ThingRequiredNullableLiteralString1.SomeValue, + "", + new int[] { 0 }, + ""); + ClientResult response = await client.InternalProtocolAsync(body).ConfigureAwait(false); + + } + + /// This sample shows how to call StillConvenient. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public void Example_SampleTypeSpec_StillConvenient_ShortVersion() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + ClientResult response = client.StillConvenient(null); + + } + + /// This sample shows how to call StillConvenientAsync. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public async Task Example_SampleTypeSpec_StillConvenient_ShortVersion_Async() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + ClientResult response = await client.StillConvenientAsync(null).ConfigureAwait(false); + + } + + /// This sample shows how to call StillConvenient. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public void Example_SampleTypeSpec_StillConvenient_ShortVersion_Convenience() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + ClientResult response = client.StillConvenient(); + + } + + /// This sample shows how to call StillConvenientAsync. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public async Task Example_SampleTypeSpec_StillConvenient_ShortVersion_Convenience_Async() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + ClientResult response = await client.StillConvenientAsync().ConfigureAwait(false); + + } + + /// This sample shows how to call StillConvenient with all request content. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public void Example_SampleTypeSpec_StillConvenient_AllParameters() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + ClientResult response = client.StillConvenient(null); + + } + + /// This sample shows how to call StillConvenientAsync with all request content. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public async Task Example_SampleTypeSpec_StillConvenient_AllParameters_Async() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + ClientResult response = await client.StillConvenientAsync(null).ConfigureAwait(false); + + } + + /// This sample shows how to call StillConvenient with all parameters. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public void Example_SampleTypeSpec_StillConvenient_AllParameters_Convenience() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + ClientResult response = client.StillConvenient(); + + } + + /// This sample shows how to call StillConvenientAsync with all parameters. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public async Task Example_SampleTypeSpec_StillConvenient_AllParameters_Convenience_Async() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + ClientResult response = await client.StillConvenientAsync().ConfigureAwait(false); + + } + + /// This sample shows how to call HeadAsBoolean. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public void Example_SampleTypeSpec_HeadAsBoolean_ShortVersion() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + ClientResult response = client.HeadAsBoolean("", null); + + } + + /// This sample shows how to call HeadAsBooleanAsync. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public async Task Example_SampleTypeSpec_HeadAsBoolean_ShortVersion_Async() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + ClientResult response = await client.HeadAsBooleanAsync("", null).ConfigureAwait(false); + + } + + /// This sample shows how to call HeadAsBoolean. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public void Example_SampleTypeSpec_HeadAsBoolean_ShortVersion_Convenience() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + ClientResult response = client.HeadAsBoolean(""); + + } + + /// This sample shows how to call HeadAsBooleanAsync. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public async Task Example_SampleTypeSpec_HeadAsBoolean_ShortVersion_Convenience_Async() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + ClientResult response = await client.HeadAsBooleanAsync("").ConfigureAwait(false); + + } + + /// This sample shows how to call HeadAsBoolean with all parameters. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public void Example_SampleTypeSpec_HeadAsBoolean_AllParameters() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + ClientResult response = client.HeadAsBoolean("", null); + + } + + /// This sample shows how to call HeadAsBooleanAsync with all parameters. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public async Task Example_SampleTypeSpec_HeadAsBoolean_AllParameters_Async() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + ClientResult response = await client.HeadAsBooleanAsync("", null).ConfigureAwait(false); + + } + + /// This sample shows how to call HeadAsBoolean with all parameters. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public void Example_SampleTypeSpec_HeadAsBoolean_AllParameters_Convenience() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + ClientResult response = client.HeadAsBoolean(""); + + } + + /// This sample shows how to call HeadAsBooleanAsync with all parameters. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public async Task Example_SampleTypeSpec_HeadAsBoolean_AllParameters_Convenience_Async() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + ClientResult response = await client.HeadAsBooleanAsync("").ConfigureAwait(false); + + } + + /// This sample shows how to call WithApiVersion. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public void Example_SampleTypeSpec_WithApiVersion_ShortVersion() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + ClientResult response = client.WithApiVersion("", null); + + } + + /// This sample shows how to call WithApiVersionAsync. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public async Task Example_SampleTypeSpec_WithApiVersion_ShortVersion_Async() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + ClientResult response = await client.WithApiVersionAsync("", null).ConfigureAwait(false); + + } + + /// This sample shows how to call WithApiVersion. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public void Example_SampleTypeSpec_WithApiVersion_ShortVersion_Convenience() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + ClientResult response = client.WithApiVersion(""); + + } + + /// This sample shows how to call WithApiVersionAsync. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public async Task Example_SampleTypeSpec_WithApiVersion_ShortVersion_Convenience_Async() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + ClientResult response = await client.WithApiVersionAsync("").ConfigureAwait(false); + + } + + /// This sample shows how to call WithApiVersion with all parameters. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public void Example_SampleTypeSpec_WithApiVersion_AllParameters() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + ClientResult response = client.WithApiVersion("", null); + + } + + /// This sample shows how to call WithApiVersionAsync with all parameters. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public async Task Example_SampleTypeSpec_WithApiVersion_AllParameters_Async() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + ClientResult response = await client.WithApiVersionAsync("", null).ConfigureAwait(false); + + } + + /// This sample shows how to call WithApiVersion with all parameters. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public void Example_SampleTypeSpec_WithApiVersion_AllParameters_Convenience() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + ClientResult response = client.WithApiVersion(""); + + } + + /// This sample shows how to call WithApiVersionAsync with all parameters. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public async Task Example_SampleTypeSpec_WithApiVersion_AllParameters_Convenience_Async() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + ClientResult response = await client.WithApiVersionAsync("").ConfigureAwait(false); + + } + + /// This sample shows how to call GetWithNextLink and parse the result. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public void Example_SampleTypeSpec_GetWithNextLink_ShortVersion() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + foreach (ClientResult page in client.GetWithNextLink(null).GetRawPages()) + { + Console.WriteLine(page.ToString()); + } + } + + /// This sample shows how to call GetWithNextLinkAsync and parse the result. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public async Task Example_SampleTypeSpec_GetWithNextLink_ShortVersion_Async() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + await foreach (ClientResult page in client.GetWithNextLinkAsync(null).GetRawPagesAsync()) + { + Console.WriteLine(page.ToString()); + } + } + + /// This sample shows how to call GetWithNextLink. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public void Example_SampleTypeSpec_GetWithNextLink_ShortVersion_Convenience() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + foreach (IList item in client.GetWithNextLink()) + { + Console.WriteLine(item.ToString()); + } + } + + /// This sample shows how to call GetWithNextLinkAsync. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public async Task Example_SampleTypeSpec_GetWithNextLink_ShortVersion_Convenience_Async() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + await foreach (IList item in client.GetWithNextLinkAsync()) + { + Console.WriteLine(item.ToString()); + } + } + + /// This sample shows how to call GetWithNextLink with all request content and parse the result. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public void Example_SampleTypeSpec_GetWithNextLink_AllParameters() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + foreach (ClientResult page in client.GetWithNextLink(null).GetRawPages()) + { + Console.WriteLine(page.ToString()); + } + } + + /// This sample shows how to call GetWithNextLinkAsync with all request content and parse the result. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public async Task Example_SampleTypeSpec_GetWithNextLink_AllParameters_Async() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + await foreach (ClientResult page in client.GetWithNextLinkAsync(null).GetRawPagesAsync()) + { + Console.WriteLine(page.ToString()); + } + } + + /// This sample shows how to call GetWithNextLink with all parameters. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public void Example_SampleTypeSpec_GetWithNextLink_AllParameters_Convenience() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + foreach (IList item in client.GetWithNextLink()) + { + Console.WriteLine(item.ToString()); + } + } + + /// This sample shows how to call GetWithNextLinkAsync with all parameters. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public async Task Example_SampleTypeSpec_GetWithNextLink_AllParameters_Convenience_Async() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + await foreach (IList item in client.GetWithNextLinkAsync()) + { + Console.WriteLine(item.ToString()); + } + } + + /// This sample shows how to call GetWithStringNextLink and parse the result. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public void Example_SampleTypeSpec_GetWithStringNextLink_ShortVersion() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + foreach (ClientResult page in client.GetWithStringNextLink(null).GetRawPages()) + { + Console.WriteLine(page.ToString()); + } + } + + /// This sample shows how to call GetWithStringNextLinkAsync and parse the result. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public async Task Example_SampleTypeSpec_GetWithStringNextLink_ShortVersion_Async() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + await foreach (ClientResult page in client.GetWithStringNextLinkAsync(null).GetRawPagesAsync()) + { + Console.WriteLine(page.ToString()); + } + } + + /// This sample shows how to call GetWithStringNextLink. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public void Example_SampleTypeSpec_GetWithStringNextLink_ShortVersion_Convenience() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + foreach (IList item in client.GetWithStringNextLink()) + { + Console.WriteLine(item.ToString()); + } + } + + /// This sample shows how to call GetWithStringNextLinkAsync. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public async Task Example_SampleTypeSpec_GetWithStringNextLink_ShortVersion_Convenience_Async() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + await foreach (IList item in client.GetWithStringNextLinkAsync()) + { + Console.WriteLine(item.ToString()); + } + } + + /// This sample shows how to call GetWithStringNextLink with all request content and parse the result. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public void Example_SampleTypeSpec_GetWithStringNextLink_AllParameters() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + foreach (ClientResult page in client.GetWithStringNextLink(null).GetRawPages()) + { + Console.WriteLine(page.ToString()); + } + } + + /// This sample shows how to call GetWithStringNextLinkAsync with all request content and parse the result. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public async Task Example_SampleTypeSpec_GetWithStringNextLink_AllParameters_Async() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + await foreach (ClientResult page in client.GetWithStringNextLinkAsync(null).GetRawPagesAsync()) + { + Console.WriteLine(page.ToString()); + } + } + + /// This sample shows how to call GetWithStringNextLink with all parameters. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public void Example_SampleTypeSpec_GetWithStringNextLink_AllParameters_Convenience() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + foreach (IList item in client.GetWithStringNextLink()) + { + Console.WriteLine(item.ToString()); + } + } + + /// This sample shows how to call GetWithStringNextLinkAsync with all parameters. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public async Task Example_SampleTypeSpec_GetWithStringNextLink_AllParameters_Convenience_Async() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + await foreach (IList item in client.GetWithStringNextLinkAsync()) + { + Console.WriteLine(item.ToString()); + } + } + + /// This sample shows how to call GetWithContinuationToken and parse the result. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public void Example_SampleTypeSpec_GetWithContinuationToken_ShortVersion() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + foreach (ClientResult page in client.GetWithContinuationToken(null, null).GetRawPages()) + { + Console.WriteLine(page.ToString()); + } + } + + /// This sample shows how to call GetWithContinuationTokenAsync and parse the result. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public async Task Example_SampleTypeSpec_GetWithContinuationToken_ShortVersion_Async() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + await foreach (ClientResult page in client.GetWithContinuationTokenAsync(null, null).GetRawPagesAsync()) + { + Console.WriteLine(page.ToString()); + } + } + + /// This sample shows how to call GetWithContinuationToken. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public void Example_SampleTypeSpec_GetWithContinuationToken_ShortVersion_Convenience() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + foreach (IList item in client.GetWithContinuationToken()) + { + Console.WriteLine(item.ToString()); + } + } + + /// This sample shows how to call GetWithContinuationTokenAsync. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public async Task Example_SampleTypeSpec_GetWithContinuationToken_ShortVersion_Convenience_Async() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + await foreach (IList item in client.GetWithContinuationTokenAsync()) + { + Console.WriteLine(item.ToString()); + } + } + + /// This sample shows how to call GetWithContinuationToken with all parameters and parse the result. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public void Example_SampleTypeSpec_GetWithContinuationToken_AllParameters() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + foreach (ClientResult page in client.GetWithContinuationToken("", null).GetRawPages()) + { + Console.WriteLine(page.ToString()); + } + } + + /// This sample shows how to call GetWithContinuationTokenAsync with all parameters and parse the result. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public async Task Example_SampleTypeSpec_GetWithContinuationToken_AllParameters_Async() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + await foreach (ClientResult page in client.GetWithContinuationTokenAsync("", null).GetRawPagesAsync()) + { + Console.WriteLine(page.ToString()); + } + } + + /// This sample shows how to call GetWithContinuationToken with all parameters. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public void Example_SampleTypeSpec_GetWithContinuationToken_AllParameters_Convenience() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + foreach (IList item in client.GetWithContinuationToken("")) + { + Console.WriteLine(item.ToString()); + } + } + + /// This sample shows how to call GetWithContinuationTokenAsync with all parameters. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public async Task Example_SampleTypeSpec_GetWithContinuationToken_AllParameters_Convenience_Async() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + await foreach (IList item in client.GetWithContinuationTokenAsync("")) + { + Console.WriteLine(item.ToString()); + } + } + + /// This sample shows how to call GetWithContinuationTokenHeaderResponse and parse the result. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public void Example_SampleTypeSpec_GetWithContinuationTokenHeaderResponse_ShortVersion() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + foreach (ClientResult page in client.GetWithContinuationTokenHeaderResponse(null, null).GetRawPages()) + { + Console.WriteLine(page.ToString()); + } + } + + /// This sample shows how to call GetWithContinuationTokenHeaderResponseAsync and parse the result. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public async Task Example_SampleTypeSpec_GetWithContinuationTokenHeaderResponse_ShortVersion_Async() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + await foreach (ClientResult page in client.GetWithContinuationTokenHeaderResponseAsync(null, null).GetRawPagesAsync()) + { + Console.WriteLine(page.ToString()); + } + } + + /// This sample shows how to call GetWithContinuationTokenHeaderResponse. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public void Example_SampleTypeSpec_GetWithContinuationTokenHeaderResponse_ShortVersion_Convenience() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + foreach (IList item in client.GetWithContinuationTokenHeaderResponse()) + { + Console.WriteLine(item.ToString()); + } + } + + /// This sample shows how to call GetWithContinuationTokenHeaderResponseAsync. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public async Task Example_SampleTypeSpec_GetWithContinuationTokenHeaderResponse_ShortVersion_Convenience_Async() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + await foreach (IList item in client.GetWithContinuationTokenHeaderResponseAsync()) + { + Console.WriteLine(item.ToString()); + } + } + + /// This sample shows how to call GetWithContinuationTokenHeaderResponse with all parameters and parse the result. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public void Example_SampleTypeSpec_GetWithContinuationTokenHeaderResponse_AllParameters() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + foreach (ClientResult page in client.GetWithContinuationTokenHeaderResponse("", null).GetRawPages()) + { + Console.WriteLine(page.ToString()); + } + } + + /// This sample shows how to call GetWithContinuationTokenHeaderResponseAsync with all parameters and parse the result. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public async Task Example_SampleTypeSpec_GetWithContinuationTokenHeaderResponse_AllParameters_Async() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + await foreach (ClientResult page in client.GetWithContinuationTokenHeaderResponseAsync("", null).GetRawPagesAsync()) + { + Console.WriteLine(page.ToString()); + } + } + + /// This sample shows how to call GetWithContinuationTokenHeaderResponse with all parameters. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public void Example_SampleTypeSpec_GetWithContinuationTokenHeaderResponse_AllParameters_Convenience() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + foreach (IList item in client.GetWithContinuationTokenHeaderResponse("")) + { + Console.WriteLine(item.ToString()); + } + } + + /// This sample shows how to call GetWithContinuationTokenHeaderResponseAsync with all parameters. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public async Task Example_SampleTypeSpec_GetWithContinuationTokenHeaderResponse_AllParameters_Convenience_Async() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + await foreach (IList item in client.GetWithContinuationTokenHeaderResponseAsync("")) + { + Console.WriteLine(item.ToString()); + } + } + + /// This sample shows how to call GetWithPaging and parse the result. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public void Example_SampleTypeSpec_GetWithPaging_ShortVersion() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + foreach (ClientResult page in client.GetWithPaging(null).GetRawPages()) + { + Console.WriteLine(page.ToString()); + } + } + + /// This sample shows how to call GetWithPagingAsync and parse the result. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public async Task Example_SampleTypeSpec_GetWithPaging_ShortVersion_Async() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + await foreach (ClientResult page in client.GetWithPagingAsync(null).GetRawPagesAsync()) + { + Console.WriteLine(page.ToString()); + } + } + + /// This sample shows how to call GetWithPaging. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public void Example_SampleTypeSpec_GetWithPaging_ShortVersion_Convenience() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + foreach (IList item in client.GetWithPaging()) + { + Console.WriteLine(item.ToString()); + } + } + + /// This sample shows how to call GetWithPagingAsync. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public async Task Example_SampleTypeSpec_GetWithPaging_ShortVersion_Convenience_Async() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + await foreach (IList item in client.GetWithPagingAsync()) + { + Console.WriteLine(item.ToString()); + } + } + + /// This sample shows how to call GetWithPaging with all request content and parse the result. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public void Example_SampleTypeSpec_GetWithPaging_AllParameters() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + foreach (ClientResult page in client.GetWithPaging(null).GetRawPages()) + { + Console.WriteLine(page.ToString()); + } + } + + /// This sample shows how to call GetWithPagingAsync with all request content and parse the result. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public async Task Example_SampleTypeSpec_GetWithPaging_AllParameters_Async() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + await foreach (ClientResult page in client.GetWithPagingAsync(null).GetRawPagesAsync()) + { + Console.WriteLine(page.ToString()); + } + } + + /// This sample shows how to call GetWithPaging with all parameters. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public void Example_SampleTypeSpec_GetWithPaging_AllParameters_Convenience() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + foreach (IList item in client.GetWithPaging()) + { + Console.WriteLine(item.ToString()); + } + } + + /// This sample shows how to call GetWithPagingAsync with all parameters. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public async Task Example_SampleTypeSpec_GetWithPaging_AllParameters_Convenience_Async() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + await foreach (IList item in client.GetWithPagingAsync()) + { + Console.WriteLine(item.ToString()); + } + } + + /// This sample shows how to call EmbeddedParameters. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public void Example_SampleTypeSpec_EmbeddedParameters_ShortVersion() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + using BinaryContent content = BinaryContent.Create(BinaryData.FromObjectAsJson(new + { + name = "", + requiredHeader = "", + requiredQuery = "" + })); + ClientResult response = client.EmbeddedParameters("", "", content); + + } + + /// This sample shows how to call EmbeddedParametersAsync. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public async Task Example_SampleTypeSpec_EmbeddedParameters_ShortVersion_Async() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + using BinaryContent content = BinaryContent.Create(BinaryData.FromObjectAsJson(new + { + name = "", + requiredHeader = "", + requiredQuery = "" + })); + ClientResult response = await client.EmbeddedParametersAsync("", "", content).ConfigureAwait(false); + + } + + /// This sample shows how to call EmbeddedParameters. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public void Example_SampleTypeSpec_EmbeddedParameters_ShortVersion_Convenience() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + ModelWithEmbeddedNonBodyParameters body = new ModelWithEmbeddedNonBodyParameters("", "", ""); + ClientResult response = client.EmbeddedParameters(body); + + } + + /// This sample shows how to call EmbeddedParametersAsync. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public async Task Example_SampleTypeSpec_EmbeddedParameters_ShortVersion_Convenience_Async() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + ModelWithEmbeddedNonBodyParameters body = new ModelWithEmbeddedNonBodyParameters("", "", ""); + ClientResult response = await client.EmbeddedParametersAsync(body).ConfigureAwait(false); + + } + + /// This sample shows how to call EmbeddedParameters with all parameters and request content. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public void Example_SampleTypeSpec_EmbeddedParameters_AllParameters() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + using BinaryContent content = BinaryContent.Create(BinaryData.FromObjectAsJson(new + { + name = "", + requiredHeader = "", + optionalHeader = "", + requiredQuery = "", + optionalQuery = "" + })); + ClientResult response = client.EmbeddedParameters("", "", content, "", ""); + + } + + /// This sample shows how to call EmbeddedParametersAsync with all parameters and request content. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public async Task Example_SampleTypeSpec_EmbeddedParameters_AllParameters_Async() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + using BinaryContent content = BinaryContent.Create(BinaryData.FromObjectAsJson(new + { + name = "", + requiredHeader = "", + optionalHeader = "", + requiredQuery = "", + optionalQuery = "" + })); + ClientResult response = await client.EmbeddedParametersAsync("", "", content, "", "").ConfigureAwait(false); + + } + + /// This sample shows how to call EmbeddedParameters with all parameters. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public void Example_SampleTypeSpec_EmbeddedParameters_AllParameters_Convenience() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + ModelWithEmbeddedNonBodyParameters body = new ModelWithEmbeddedNonBodyParameters("", "", ""); + ClientResult response = client.EmbeddedParameters(body); + + } + + /// This sample shows how to call EmbeddedParametersAsync with all parameters. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public async Task Example_SampleTypeSpec_EmbeddedParameters_AllParameters_Convenience_Async() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + ModelWithEmbeddedNonBodyParameters body = new ModelWithEmbeddedNonBodyParameters("", "", ""); + ClientResult response = await client.EmbeddedParametersAsync(body).ConfigureAwait(false); + + } + + /// This sample shows how to call DynamicModelOperation. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public void Example_SampleTypeSpec_DynamicModelOperation_ShortVersion() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + using BinaryContent content = BinaryContent.Create(BinaryData.FromObjectAsJson(new + { + name = "", + requiredNullableList = new object[] { 0 }, + requiredNullableDictionary = new + { + key = 0 + }, + primitiveDictionary = new + { + key = 0 + }, + foo = new + { + bar = "" + }, + listFoo = new object[] { null }, + listOfListFoo = new object[] { new object[] { null } }, + dictionaryFoo = new object(), + dictionaryOfDictionaryFoo = new + { + key = new object() + }, + dictionaryListFoo = new + { + key = new object[] { null } + }, + listOfDictionaryFoo = new object[] { new object() } + })); + ClientResult response = client.DynamicModelOperation(content); + + } + + /// This sample shows how to call DynamicModelOperationAsync. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public async Task Example_SampleTypeSpec_DynamicModelOperation_ShortVersion_Async() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + using BinaryContent content = BinaryContent.Create(BinaryData.FromObjectAsJson(new + { + name = "", + requiredNullableList = new object[] { 0 }, + requiredNullableDictionary = new + { + key = 0 + }, + primitiveDictionary = new + { + key = 0 + }, + foo = new + { + bar = "" + }, + listFoo = new object[] { null }, + listOfListFoo = new object[] { new object[] { null } }, + dictionaryFoo = new object(), + dictionaryOfDictionaryFoo = new + { + key = new object() + }, + dictionaryListFoo = new + { + key = new object[] { null } + }, + listOfDictionaryFoo = new object[] { new object() } + })); + ClientResult response = await client.DynamicModelOperationAsync(content).ConfigureAwait(false); + + } + + /// This sample shows how to call DynamicModelOperation. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public void Example_SampleTypeSpec_DynamicModelOperation_ShortVersion_Convenience() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + DynamicModel body = new DynamicModel( + "", + new int[] { 0 }, + new Dictionary + { + { "key", 0 } + }, + new Dictionary + { + { "key", 0 } + }, + new AnotherDynamicModel(""), + new AnotherDynamicModel[] { new AnotherDynamicModel() }, + new IList[] { new AnotherDynamicModel[] { new AnotherDynamicModel() } }, + new Dictionary + { + { "key", new AnotherDynamicModel() } + }, + new Dictionary> + { + { "key", new Dictionary + { + { "key", new AnotherDynamicModel() } + } } + }, + new Dictionary> + { + { "key", new AnotherDynamicModel[] { new AnotherDynamicModel() } } + }, + new IDictionary[] { new Dictionary + { + { "key", new AnotherDynamicModel() } + } }); + ClientResult response = client.DynamicModelOperation(body); + + } + + /// This sample shows how to call DynamicModelOperationAsync. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public async Task Example_SampleTypeSpec_DynamicModelOperation_ShortVersion_Convenience_Async() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + DynamicModel body = new DynamicModel( + "", + new int[] { 0 }, + new Dictionary + { + { "key", 0 } + }, + new Dictionary + { + { "key", 0 } + }, + new AnotherDynamicModel(""), + new AnotherDynamicModel[] { new AnotherDynamicModel() }, + new IList[] { new AnotherDynamicModel[] { new AnotherDynamicModel() } }, + new Dictionary + { + { "key", new AnotherDynamicModel() } + }, + new Dictionary> + { + { "key", new Dictionary + { + { "key", new AnotherDynamicModel() } + } } + }, + new Dictionary> + { + { "key", new AnotherDynamicModel[] { new AnotherDynamicModel() } } + }, + new IDictionary[] { new Dictionary + { + { "key", new AnotherDynamicModel() } + } }); + ClientResult response = await client.DynamicModelOperationAsync(body).ConfigureAwait(false); + + } + + /// This sample shows how to call DynamicModelOperation with all request content. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public void Example_SampleTypeSpec_DynamicModelOperation_AllParameters() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + using BinaryContent content = BinaryContent.Create(BinaryData.FromObjectAsJson(new + { + name = "", + optionalUnknown = "", + optionalInt = 0, + optionalNullableList = new object[] { 0 }, + requiredNullableList = new object[] { 0 }, + optionalNullableDictionary = new + { + key = 0 + }, + requiredNullableDictionary = new + { + key = 0 + }, + primitiveDictionary = new + { + key = 0 + }, + foo = new + { + bar = "" + }, + listFoo = new object[] { null }, + listOfListFoo = new object[] { new object[] { null } }, + dictionaryFoo = new object(), + dictionaryOfDictionaryFoo = new + { + key = new object() + }, + dictionaryListFoo = new + { + key = new object[] { null } + }, + listOfDictionaryFoo = new object[] { new object() } + })); + ClientResult response = client.DynamicModelOperation(content); + + } + + /// This sample shows how to call DynamicModelOperationAsync with all request content. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public async Task Example_SampleTypeSpec_DynamicModelOperation_AllParameters_Async() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + using BinaryContent content = BinaryContent.Create(BinaryData.FromObjectAsJson(new + { + name = "", + optionalUnknown = "", + optionalInt = 0, + optionalNullableList = new object[] { 0 }, + requiredNullableList = new object[] { 0 }, + optionalNullableDictionary = new + { + key = 0 + }, + requiredNullableDictionary = new + { + key = 0 + }, + primitiveDictionary = new + { + key = 0 + }, + foo = new + { + bar = "" + }, + listFoo = new object[] { null }, + listOfListFoo = new object[] { new object[] { null } }, + dictionaryFoo = new object(), + dictionaryOfDictionaryFoo = new + { + key = new object() + }, + dictionaryListFoo = new + { + key = new object[] { null } + }, + listOfDictionaryFoo = new object[] { new object() } + })); + ClientResult response = await client.DynamicModelOperationAsync(content).ConfigureAwait(false); + + } + + /// This sample shows how to call DynamicModelOperation with all parameters. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public void Example_SampleTypeSpec_DynamicModelOperation_AllParameters_Convenience() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + DynamicModel body = new DynamicModel( + "", + new int[] { 0 }, + new Dictionary + { + { "key", 0 } + }, + new Dictionary + { + { "key", 0 } + }, + new AnotherDynamicModel(""), + new AnotherDynamicModel[] { new AnotherDynamicModel() }, + new IList[] { new AnotherDynamicModel[] { new AnotherDynamicModel() } }, + new Dictionary + { + { "key", new AnotherDynamicModel() } + }, + new Dictionary> + { + { "key", new Dictionary + { + { "key", new AnotherDynamicModel() } + } } + }, + new Dictionary> + { + { "key", new AnotherDynamicModel[] { new AnotherDynamicModel() } } + }, + new IDictionary[] { new Dictionary + { + { "key", new AnotherDynamicModel() } + } }); + ClientResult response = client.DynamicModelOperation(body); + + } + + /// This sample shows how to call DynamicModelOperationAsync with all parameters. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public async Task Example_SampleTypeSpec_DynamicModelOperation_AllParameters_Convenience_Async() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + DynamicModel body = new DynamicModel( + "", + new int[] { 0 }, + new Dictionary + { + { "key", 0 } + }, + new Dictionary + { + { "key", 0 } + }, + new AnotherDynamicModel(""), + new AnotherDynamicModel[] { new AnotherDynamicModel() }, + new IList[] { new AnotherDynamicModel[] { new AnotherDynamicModel() } }, + new Dictionary + { + { "key", new AnotherDynamicModel() } + }, + new Dictionary> + { + { "key", new Dictionary + { + { "key", new AnotherDynamicModel() } + } } + }, + new Dictionary> + { + { "key", new AnotherDynamicModel[] { new AnotherDynamicModel() } } + }, + new IDictionary[] { new Dictionary + { + { "key", new AnotherDynamicModel() } + } }); + ClientResult response = await client.DynamicModelOperationAsync(body).ConfigureAwait(false); + + } + + /// This sample shows how to call GetXmlAdvancedModel and parse the result. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public void Example_SampleTypeSpec_GetXmlAdvancedModel_ShortVersion() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + ClientResult response = client.GetXmlAdvancedModel(null); + + JsonElement result = JsonDocument.Parse(response.GetRawResponse().ContentStream).RootElement; + Console.WriteLine(result.GetProperty("name").ToString()); + Console.WriteLine(result.GetProperty("age").ToString()); + Console.WriteLine(result.GetProperty("enabled").ToString()); + Console.WriteLine(result.GetProperty("score").ToString()); + Console.WriteLine(result.GetProperty("nullableString").ToString()); + Console.WriteLine(result.GetProperty("id").ToString()); + Console.WriteLine(result.GetProperty("version").ToString()); + Console.WriteLine(result.GetProperty("isActive").ToString()); + Console.WriteLine(result.GetProperty("RenamedProperty").ToString()); + Console.WriteLine(result.GetProperty("xml-id").ToString()); + Console.WriteLine(result.GetProperty("content").ToString()); + Console.WriteLine(result.GetProperty("unwrappedStrings")[0].ToString()); + Console.WriteLine(result.GetProperty("unwrappedCounts")[0].ToString()); + Console.WriteLine(result.GetProperty("unwrappedItems")[0].GetProperty("itemName").ToString()); + Console.WriteLine(result.GetProperty("unwrappedItems")[0].GetProperty("itemValue").ToString()); + Console.WriteLine(result.GetProperty("unwrappedItems")[0].GetProperty("itemId").ToString()); + Console.WriteLine(result.GetProperty("wrappedColors")[0].ToString()); + Console.WriteLine(result.GetProperty("ItemCollection")[0].GetProperty("itemName").ToString()); + Console.WriteLine(result.GetProperty("ItemCollection")[0].GetProperty("itemValue").ToString()); + Console.WriteLine(result.GetProperty("ItemCollection")[0].GetProperty("itemId").ToString()); + Console.WriteLine(result.GetProperty("nestedModel").GetProperty("value").ToString()); + Console.WriteLine(result.GetProperty("nestedModel").GetProperty("nestedId").ToString()); + Console.WriteLine(result.GetProperty("metadata").ToString()); + Console.WriteLine(result.GetProperty("createdAt").ToString()); + Console.WriteLine(result.GetProperty("duration").ToString()); + Console.WriteLine(result.GetProperty("data").ToString()); + Console.WriteLine(result.GetProperty("fixedEnum").ToString()); + Console.WriteLine(result.GetProperty("extensibleEnum").ToString()); + Console.WriteLine(result.GetProperty("label").ToString()); + Console.WriteLine(result.GetProperty("daysUsed").ToString()); + Console.WriteLine(result.GetProperty("fooItems")[0].ToString()); + Console.WriteLine(result.GetProperty("anotherModel").GetProperty("value").ToString()); + Console.WriteLine(result.GetProperty("anotherModel").GetProperty("nestedId").ToString()); + Console.WriteLine(result.GetProperty("modelsWithNamespaces")[0].GetProperty("foo").ToString()); + Console.WriteLine(result.GetProperty("unwrappedModelsWithNamespaces")[0].GetProperty("foo").ToString()); + Console.WriteLine(result.GetProperty("listOfListFoo")[0][0].GetProperty("itemName").ToString()); + Console.WriteLine(result.GetProperty("listOfListFoo")[0][0].GetProperty("itemValue").ToString()); + Console.WriteLine(result.GetProperty("listOfListFoo")[0][0].GetProperty("itemId").ToString()); + Console.WriteLine(result.GetProperty("dictionaryFoo").ToString()); + Console.WriteLine(result.GetProperty("dictionaryOfDictionaryFoo").ToString()); + Console.WriteLine(result.GetProperty("dictionaryListFoo").ToString()); + Console.WriteLine(result.GetProperty("listOfDictionaryFoo")[0].ToString()); + } + + /// This sample shows how to call GetXmlAdvancedModelAsync and parse the result. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public async Task Example_SampleTypeSpec_GetXmlAdvancedModel_ShortVersion_Async() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + ClientResult response = await client.GetXmlAdvancedModelAsync(null).ConfigureAwait(false); + + JsonElement result = JsonDocument.Parse(response.GetRawResponse().ContentStream).RootElement; + Console.WriteLine(result.GetProperty("name").ToString()); + Console.WriteLine(result.GetProperty("age").ToString()); + Console.WriteLine(result.GetProperty("enabled").ToString()); + Console.WriteLine(result.GetProperty("score").ToString()); + Console.WriteLine(result.GetProperty("nullableString").ToString()); + Console.WriteLine(result.GetProperty("id").ToString()); + Console.WriteLine(result.GetProperty("version").ToString()); + Console.WriteLine(result.GetProperty("isActive").ToString()); + Console.WriteLine(result.GetProperty("RenamedProperty").ToString()); + Console.WriteLine(result.GetProperty("xml-id").ToString()); + Console.WriteLine(result.GetProperty("content").ToString()); + Console.WriteLine(result.GetProperty("unwrappedStrings")[0].ToString()); + Console.WriteLine(result.GetProperty("unwrappedCounts")[0].ToString()); + Console.WriteLine(result.GetProperty("unwrappedItems")[0].GetProperty("itemName").ToString()); + Console.WriteLine(result.GetProperty("unwrappedItems")[0].GetProperty("itemValue").ToString()); + Console.WriteLine(result.GetProperty("unwrappedItems")[0].GetProperty("itemId").ToString()); + Console.WriteLine(result.GetProperty("wrappedColors")[0].ToString()); + Console.WriteLine(result.GetProperty("ItemCollection")[0].GetProperty("itemName").ToString()); + Console.WriteLine(result.GetProperty("ItemCollection")[0].GetProperty("itemValue").ToString()); + Console.WriteLine(result.GetProperty("ItemCollection")[0].GetProperty("itemId").ToString()); + Console.WriteLine(result.GetProperty("nestedModel").GetProperty("value").ToString()); + Console.WriteLine(result.GetProperty("nestedModel").GetProperty("nestedId").ToString()); + Console.WriteLine(result.GetProperty("metadata").ToString()); + Console.WriteLine(result.GetProperty("createdAt").ToString()); + Console.WriteLine(result.GetProperty("duration").ToString()); + Console.WriteLine(result.GetProperty("data").ToString()); + Console.WriteLine(result.GetProperty("fixedEnum").ToString()); + Console.WriteLine(result.GetProperty("extensibleEnum").ToString()); + Console.WriteLine(result.GetProperty("label").ToString()); + Console.WriteLine(result.GetProperty("daysUsed").ToString()); + Console.WriteLine(result.GetProperty("fooItems")[0].ToString()); + Console.WriteLine(result.GetProperty("anotherModel").GetProperty("value").ToString()); + Console.WriteLine(result.GetProperty("anotherModel").GetProperty("nestedId").ToString()); + Console.WriteLine(result.GetProperty("modelsWithNamespaces")[0].GetProperty("foo").ToString()); + Console.WriteLine(result.GetProperty("unwrappedModelsWithNamespaces")[0].GetProperty("foo").ToString()); + Console.WriteLine(result.GetProperty("listOfListFoo")[0][0].GetProperty("itemName").ToString()); + Console.WriteLine(result.GetProperty("listOfListFoo")[0][0].GetProperty("itemValue").ToString()); + Console.WriteLine(result.GetProperty("listOfListFoo")[0][0].GetProperty("itemId").ToString()); + Console.WriteLine(result.GetProperty("dictionaryFoo").ToString()); + Console.WriteLine(result.GetProperty("dictionaryOfDictionaryFoo").ToString()); + Console.WriteLine(result.GetProperty("dictionaryListFoo").ToString()); + Console.WriteLine(result.GetProperty("listOfDictionaryFoo")[0].ToString()); + } + + /// This sample shows how to call GetXmlAdvancedModel. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public void Example_SampleTypeSpec_GetXmlAdvancedModel_ShortVersion_Convenience() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + ClientResult response = client.GetXmlAdvancedModel(); + + } + + /// This sample shows how to call GetXmlAdvancedModelAsync. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public async Task Example_SampleTypeSpec_GetXmlAdvancedModel_ShortVersion_Convenience_Async() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + ClientResult response = await client.GetXmlAdvancedModelAsync().ConfigureAwait(false); + + } + + /// This sample shows how to call GetXmlAdvancedModel with all request content and parse the result. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public void Example_SampleTypeSpec_GetXmlAdvancedModel_AllParameters() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + ClientResult response = client.GetXmlAdvancedModel(null); + + JsonElement result = JsonDocument.Parse(response.GetRawResponse().ContentStream).RootElement; + Console.WriteLine(result.GetProperty("name").ToString()); + Console.WriteLine(result.GetProperty("age").ToString()); + Console.WriteLine(result.GetProperty("enabled").ToString()); + Console.WriteLine(result.GetProperty("score").ToString()); + Console.WriteLine(result.GetProperty("optionalString").ToString()); + Console.WriteLine(result.GetProperty("optionalInt").ToString()); + Console.WriteLine(result.GetProperty("nullableString").ToString()); + Console.WriteLine(result.GetProperty("id").ToString()); + Console.WriteLine(result.GetProperty("version").ToString()); + Console.WriteLine(result.GetProperty("isActive").ToString()); + Console.WriteLine(result.GetProperty("RenamedProperty").ToString()); + Console.WriteLine(result.GetProperty("xml-id").ToString()); + Console.WriteLine(result.GetProperty("content").ToString()); + Console.WriteLine(result.GetProperty("unwrappedStrings")[0].ToString()); + Console.WriteLine(result.GetProperty("unwrappedCounts")[0].ToString()); + Console.WriteLine(result.GetProperty("unwrappedItems")[0].GetProperty("itemName").ToString()); + Console.WriteLine(result.GetProperty("unwrappedItems")[0].GetProperty("itemValue").ToString()); + Console.WriteLine(result.GetProperty("unwrappedItems")[0].GetProperty("itemId").ToString()); + Console.WriteLine(result.GetProperty("wrappedColors")[0].ToString()); + Console.WriteLine(result.GetProperty("ItemCollection")[0].GetProperty("itemName").ToString()); + Console.WriteLine(result.GetProperty("ItemCollection")[0].GetProperty("itemValue").ToString()); + Console.WriteLine(result.GetProperty("ItemCollection")[0].GetProperty("itemId").ToString()); + Console.WriteLine(result.GetProperty("nestedModel").GetProperty("value").ToString()); + Console.WriteLine(result.GetProperty("nestedModel").GetProperty("nestedId").ToString()); + Console.WriteLine(result.GetProperty("optionalNestedModel").GetProperty("value").ToString()); + Console.WriteLine(result.GetProperty("optionalNestedModel").GetProperty("nestedId").ToString()); + Console.WriteLine(result.GetProperty("metadata").ToString()); + Console.WriteLine(result.GetProperty("createdAt").ToString()); + Console.WriteLine(result.GetProperty("duration").ToString()); + Console.WriteLine(result.GetProperty("data").ToString()); + Console.WriteLine(result.GetProperty("optionalRecordUnknown").ToString()); + Console.WriteLine(result.GetProperty("fixedEnum").ToString()); + Console.WriteLine(result.GetProperty("extensibleEnum").ToString()); + Console.WriteLine(result.GetProperty("optionalFixedEnum").ToString()); + Console.WriteLine(result.GetProperty("optionalExtensibleEnum").ToString()); + Console.WriteLine(result.GetProperty("label").ToString()); + Console.WriteLine(result.GetProperty("daysUsed").ToString()); + Console.WriteLine(result.GetProperty("fooItems")[0].ToString()); + Console.WriteLine(result.GetProperty("anotherModel").GetProperty("value").ToString()); + Console.WriteLine(result.GetProperty("anotherModel").GetProperty("nestedId").ToString()); + Console.WriteLine(result.GetProperty("modelsWithNamespaces")[0].GetProperty("foo").ToString()); + Console.WriteLine(result.GetProperty("unwrappedModelsWithNamespaces")[0].GetProperty("foo").ToString()); + Console.WriteLine(result.GetProperty("listOfListFoo")[0][0].GetProperty("itemName").ToString()); + Console.WriteLine(result.GetProperty("listOfListFoo")[0][0].GetProperty("itemValue").ToString()); + Console.WriteLine(result.GetProperty("listOfListFoo")[0][0].GetProperty("itemId").ToString()); + Console.WriteLine(result.GetProperty("dictionaryFoo").ToString()); + Console.WriteLine(result.GetProperty("dictionaryOfDictionaryFoo").ToString()); + Console.WriteLine(result.GetProperty("dictionaryListFoo").ToString()); + Console.WriteLine(result.GetProperty("listOfDictionaryFoo")[0].ToString()); + } + + /// This sample shows how to call GetXmlAdvancedModelAsync with all request content and parse the result. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public async Task Example_SampleTypeSpec_GetXmlAdvancedModel_AllParameters_Async() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + ClientResult response = await client.GetXmlAdvancedModelAsync(null).ConfigureAwait(false); + + JsonElement result = JsonDocument.Parse(response.GetRawResponse().ContentStream).RootElement; + Console.WriteLine(result.GetProperty("name").ToString()); + Console.WriteLine(result.GetProperty("age").ToString()); + Console.WriteLine(result.GetProperty("enabled").ToString()); + Console.WriteLine(result.GetProperty("score").ToString()); + Console.WriteLine(result.GetProperty("optionalString").ToString()); + Console.WriteLine(result.GetProperty("optionalInt").ToString()); + Console.WriteLine(result.GetProperty("nullableString").ToString()); + Console.WriteLine(result.GetProperty("id").ToString()); + Console.WriteLine(result.GetProperty("version").ToString()); + Console.WriteLine(result.GetProperty("isActive").ToString()); + Console.WriteLine(result.GetProperty("RenamedProperty").ToString()); + Console.WriteLine(result.GetProperty("xml-id").ToString()); + Console.WriteLine(result.GetProperty("content").ToString()); + Console.WriteLine(result.GetProperty("unwrappedStrings")[0].ToString()); + Console.WriteLine(result.GetProperty("unwrappedCounts")[0].ToString()); + Console.WriteLine(result.GetProperty("unwrappedItems")[0].GetProperty("itemName").ToString()); + Console.WriteLine(result.GetProperty("unwrappedItems")[0].GetProperty("itemValue").ToString()); + Console.WriteLine(result.GetProperty("unwrappedItems")[0].GetProperty("itemId").ToString()); + Console.WriteLine(result.GetProperty("wrappedColors")[0].ToString()); + Console.WriteLine(result.GetProperty("ItemCollection")[0].GetProperty("itemName").ToString()); + Console.WriteLine(result.GetProperty("ItemCollection")[0].GetProperty("itemValue").ToString()); + Console.WriteLine(result.GetProperty("ItemCollection")[0].GetProperty("itemId").ToString()); + Console.WriteLine(result.GetProperty("nestedModel").GetProperty("value").ToString()); + Console.WriteLine(result.GetProperty("nestedModel").GetProperty("nestedId").ToString()); + Console.WriteLine(result.GetProperty("optionalNestedModel").GetProperty("value").ToString()); + Console.WriteLine(result.GetProperty("optionalNestedModel").GetProperty("nestedId").ToString()); + Console.WriteLine(result.GetProperty("metadata").ToString()); + Console.WriteLine(result.GetProperty("createdAt").ToString()); + Console.WriteLine(result.GetProperty("duration").ToString()); + Console.WriteLine(result.GetProperty("data").ToString()); + Console.WriteLine(result.GetProperty("optionalRecordUnknown").ToString()); + Console.WriteLine(result.GetProperty("fixedEnum").ToString()); + Console.WriteLine(result.GetProperty("extensibleEnum").ToString()); + Console.WriteLine(result.GetProperty("optionalFixedEnum").ToString()); + Console.WriteLine(result.GetProperty("optionalExtensibleEnum").ToString()); + Console.WriteLine(result.GetProperty("label").ToString()); + Console.WriteLine(result.GetProperty("daysUsed").ToString()); + Console.WriteLine(result.GetProperty("fooItems")[0].ToString()); + Console.WriteLine(result.GetProperty("anotherModel").GetProperty("value").ToString()); + Console.WriteLine(result.GetProperty("anotherModel").GetProperty("nestedId").ToString()); + Console.WriteLine(result.GetProperty("modelsWithNamespaces")[0].GetProperty("foo").ToString()); + Console.WriteLine(result.GetProperty("unwrappedModelsWithNamespaces")[0].GetProperty("foo").ToString()); + Console.WriteLine(result.GetProperty("listOfListFoo")[0][0].GetProperty("itemName").ToString()); + Console.WriteLine(result.GetProperty("listOfListFoo")[0][0].GetProperty("itemValue").ToString()); + Console.WriteLine(result.GetProperty("listOfListFoo")[0][0].GetProperty("itemId").ToString()); + Console.WriteLine(result.GetProperty("dictionaryFoo").ToString()); + Console.WriteLine(result.GetProperty("dictionaryOfDictionaryFoo").ToString()); + Console.WriteLine(result.GetProperty("dictionaryListFoo").ToString()); + Console.WriteLine(result.GetProperty("listOfDictionaryFoo")[0].ToString()); + } + + /// This sample shows how to call GetXmlAdvancedModel with all parameters. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public void Example_SampleTypeSpec_GetXmlAdvancedModel_AllParameters_Convenience() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + ClientResult response = client.GetXmlAdvancedModel(); + + } + + /// This sample shows how to call GetXmlAdvancedModelAsync with all parameters. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public async Task Example_SampleTypeSpec_GetXmlAdvancedModel_AllParameters_Convenience_Async() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + ClientResult response = await client.GetXmlAdvancedModelAsync().ConfigureAwait(false); + + } + + /// This sample shows how to call UpdateXmlAdvancedModel and parse the result. + [global::NUnit.Framework.TestAttribute] + [global::NUnit.Framework.IgnoreAttribute("Only validating compilation of examples")] + public void Example_SampleTypeSpec_UpdateXmlAdvancedModel_ShortVersion() + { + Uri endpoint = new Uri(""); + ApiKeyCredential credential = new ApiKeyCredential(""); + SampleTypeSpecClient client = new SampleTypeSpecClient(endpoint, credential); + + using BinaryContent content = BinaryContent.Create(BinaryData.FromObjectAsJson(new + { + name = "", + age = 0, + enabled = true, + score = 0, + nullableString = "", + id = "", + version = 0, + isActive = true, + renamedProperty = "", + xmlId = "", + content = "", + unwrappedStrings = new object[] { "" }, + unwrappedCounts = new object[] { 0 }, + unwrappedItems = new object[] { new + { + itemName = "", + itemValue = 0, + itemId = "" + } }, + wrappedColors = new object[] { "" }, + itemCollection = new object[] { null }, + nestedModel = new + { + value = "", + nestedId = 0 + }, + metadata = new + { + key = "" + }, + createdAt = "", + duration = "", + data = "", + fixedEnum = "1", + extensibleEnum = "1", + label = "