From ca8a3fdaf8d87007b5e127335b609984e168e347 Mon Sep 17 00:00:00 2001 From: LazyLinh2 Date: Thu, 14 May 2026 10:03:57 -0700 Subject: [PATCH 01/12] OperationSample --- .../src/Primitives/ScmKnownParameters.cs | 4 + .../src/Providers/Samples/OperationSample.cs | 749 ++++++++++++++++++ .../Providers/ScmMethodProviderCollection.cs | 44 + .../Providers/Samples/OperationSampleTests.cs | 586 ++++++++++++++ .../ScmMethodProviderCollectionTests.cs | 79 ++ .../test/ScmKnownParametersTests.cs | 13 + 6 files changed, 1475 insertions(+) create mode 100644 packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/src/Providers/Samples/OperationSample.cs create mode 100644 packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/test/Providers/Samples/OperationSampleTests.cs 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..336fc35dff0 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; @@ -66,5 +67,8 @@ public static ParameterProvider ClientOptions(CSharpType clientOptionsType) public static readonly ParameterProvider NextPage = new ParameterProvider("nextPage", $"The url of the next page of responses.", typeof(Uri)); + + public static readonly ParameterProvider KeyCredential = new("credential", FormattableStringHelpers.Empty, typeof(ApiKeyCredential)); + public static readonly ParameterProvider TokenCredential = new("credential", FormattableStringHelpers.Empty, typeof(AuthenticationTokenProvider)); } } 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..8e35ee9e267 --- /dev/null +++ b/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/src/Providers/Samples/OperationSample.cs @@ -0,0 +1,749 @@ +// 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 current client up to root, collecting factory methods + 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; + } + + // Endpoint (Uri) — use provided example value, otherwise a named placeholder like "" + if (type.Equals(typeof(Uri)) && parameter.InputParameter is InputEndpointParameter) + { + 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("")` + if (type.Equals(ScmKnownParameters.KeyCredential.Type) || + type.Name == ScmKnownParameters.KeyCredential.Type.Name || + type.Name == "AzureKeyCredential") + { + result[parameter.Name] = new ExampleParameterValue( + parameter.Name, type, New.Instance(type, Literal(""))); + return true; + } + + // TokenCredential — produce `new DefaultAzureCredential()` + if (type.Equals(ScmKnownParameters.TokenCredential.Type) || + type.Name == ScmKnownParameters.TokenCredential.Type.Name || + type.Name == "TokenCredential") + { + result[parameter.Name] = new ExampleParameterValue( + parameter.Name, type, New.Instance(type)); + return true; + } + + // ClientOptions — skip (optional, not needed in sample) + if (parameter.Name.EndsWith("Options", StringComparison.OrdinalIgnoreCase) && parameter.DefaultValue != 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) + { + ValueExpression parameterExpression; + + if (ParameterValueMapping.TryGetValue(parameter.Name, out var exampleValue)) + { + parameterExpression = ExampleValueExpressionBuilder.GetExpression(exampleValue); + } + else + { + // No example value — skip optional, use default for required + if (parameter.DefaultValue != 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 + if (type.Equals(ScmKnownParameters.KeyCredential.Type) || + type.Name == ScmKnownParameters.KeyCredential.Type.Name || + type.Name == "AzureKeyCredential" || + type.Equals(ScmKnownParameters.TokenCredential.Type) || + type.Name == ScmKnownParameters.TokenCredential.Type.Name || + type.Name == "TokenCredential") + 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 identica. + 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/Providers/ScmMethodProviderCollection.cs b/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/src/Providers/ScmMethodProviderCollection.cs index 1441718d0a5..e29cbc549b9 100644 --- a/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/src/Providers/ScmMethodProviderCollection.cs +++ b/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/src/Providers/ScmMethodProviderCollection.cs @@ -12,6 +12,7 @@ using System.Threading.Tasks; using System.Xml.Linq; using Microsoft.TypeSpec.Generator.ClientModel.Primitives; +using Microsoft.TypeSpec.Generator.ClientModel.Providers.Samples; using Microsoft.TypeSpec.Generator.ClientModel.Snippets; using Microsoft.TypeSpec.Generator.ClientModel.Utilities; using Microsoft.TypeSpec.Generator.EmitterRpc; @@ -40,12 +41,14 @@ public class ScmMethodProviderCollection : IReadOnlyList private IReadOnlyList? _convenienceMethodParameters; private readonly InputPagingServiceMethod? _pagingServiceMethod; private IReadOnlyList? _methods; + private IReadOnlyList? _samples; private readonly bool _generateConvenienceMethod; private ClientProvider Client { get; } protected InputServiceMethod ServiceMethod { get; } protected TypeProvider EnclosingType { get; } public IReadOnlyList MethodProviders => _methods ??= BuildMethods(); + public IReadOnlyList Samples => _samples ??= BuildSamples(); public ScmMethodProvider this[int index] { @@ -108,6 +111,47 @@ protected virtual IReadOnlyList BuildMethods() ]; } + protected virtual IReadOnlyList BuildSamples() + { + if (ServiceMethod.Operation.Examples.Count == 0) + { + return []; + } + + var protocolMethod = MethodProviders.FirstOrDefault(m => + m.Kind == ScmMethodKind.Protocol && + !m.Signature.Modifiers.HasFlag(MethodSignatureModifiers.Async)); + + if (protocolMethod == null || !OperationSample.ShouldGenerateSample(Client, protocolMethod.Signature)) + { + return []; + } + + bool shouldGenerateShortVersion = OperationSample.ShouldGenerateShortVersion(this); + bool shouldGenerateConvenienceSamples = MethodProviders.Any(m => + m.Kind == ScmMethodKind.Convenience && + !m.Signature.Modifiers.HasFlag(MethodSignatureModifiers.Async) && + m.Signature.Modifiers.HasFlag(MethodSignatureModifiers.Public)); + + List samples = new(); + foreach (var example in ServiceMethod.Operation.Examples) + { + if (!shouldGenerateShortVersion && example.Name == "ShortVersion") + { + continue; + } + + samples.Add(new OperationSample(Client, this, ServiceMethod, example, false, example.Name)); + + if (shouldGenerateConvenienceSamples) + { + samples.Add(new OperationSample(Client, this, ServiceMethod, example, true, example.Name)); + } + } + + return samples; + } + private ScmMethodProvider BuildConvenienceMethod(MethodProvider protocolMethod, bool isAsync) { if (EnclosingType is not ClientProvider client) 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..0f753a9ebf9 --- /dev/null +++ b/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/test/Providers/Samples/OperationSampleTests.cs @@ -0,0 +1,586 @@ +// 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 System.ClientModel.Primitives; +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.Statements; +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(); + } + + // ------------------------------------------------------------------- + // Core identity properties + // ------------------------------------------------------------------- + + [Test] + public void ExampleKey_PreservedFromInput() + { + var sample = CreateBasicSample("ShortVersion"); + Assert.AreEqual("ShortVersion", sample.ExampleKey); + } + + [Test] + public void IsAllParametersUsed_TrueForAllParameters() + { + var sample = CreateBasicSample("AllParameters"); + Assert.IsTrue(sample.IsAllParametersUsed); + } + + [Test] + public void IsAllParametersUsed_FalseForShortVersion() + { + var sample = CreateBasicSample("ShortVersion"); + Assert.IsFalse(sample.IsAllParametersUsed); + } + + [Test] + public void IsConvenienceSample_PreservedFromInput() + { + var sample = CreateBasicSample("ShortVersion", isConvenience: true); + Assert.IsTrue(sample.IsConvenienceSample); + } + + [Test] + public void InputOperationName_PreservedFromServiceMethod() + { + var sample = CreateBasicSample("ShortVersion"); + Assert.AreEqual("TestOperation", sample.InputOperationName); + } + + [Test] + public void ResourceName_FallsBackToClientName() + { + var sample = CreateBasicSample("ShortVersion"); + // InputFactory.Operation sets ResourceName to null, + // so falls back to client name + Assert.AreEqual("TestClient", sample.ResourceName); + } + + // ------------------------------------------------------------------- + // Operation type detection + // ------------------------------------------------------------------- + + [Test] + public void IsPageable_FalseForBasicMethod() + { + var sample = CreateBasicSample("ShortVersion"); + Assert.IsFalse(sample.IsPageable); + } + + [Test] + public void IsPageable_TrueForPagingMethod() + { + var operation = InputFactory.Operation("ListItems"); + var pagingMetadata = InputFactory.PagingMetadata(["items"], null, null); + var serviceMethod = InputFactory.PagingServiceMethod("ListItems", operation, pagingMetadata: pagingMetadata); + + // Verify the service method is recognized as paging + Assert.IsInstanceOf(serviceMethod); + } + + [Test] + public void IsLongRunning_FalseForBasicMethod() + { + var sample = CreateBasicSample("ShortVersion"); + Assert.IsFalse(sample.IsLongRunning); + } + + [Test] + public void HasResponseBody_FalseForVoidReturn() + { + var sample = CreateBasicSample("ShortVersion"); + // Basic operation with no response type → no body + Assert.IsFalse(sample.HasResponseBody); + } + + // ------------------------------------------------------------------- + // Client invocation chain — root client + // ------------------------------------------------------------------- + + [Test] + public void ClientInvocationChain_RootClient_HasSingleConstructor() + { + var sample = CreateBasicSample("ShortVersion"); + var chain = sample.ClientInvocationChain; + + Assert.IsTrue(chain.Count >= 1); + Assert.IsInstanceOf(chain[0]); + } + + // ------------------------------------------------------------------- + // Client invocation chain — subclient + // ------------------------------------------------------------------- + + [Test] + public void ClientInvocationChain_SubClient_HasConstructorAndFactory() + { + var (sample, _, _) = CreateSubClientSample("ShortVersion"); + var chain = sample.ClientInvocationChain; + + Assert.IsTrue(chain.Count >= 2); + Assert.IsInstanceOf(chain[0]); + Assert.IsInstanceOf(chain[1]); + } + + // ------------------------------------------------------------------- + // Parameter value mapping + // ------------------------------------------------------------------- + + [Test] + public void ParameterMapping_SpecProvidedValue_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); + + // Use convenience sample so the parameter name "message" is preserved + var sample = new OperationSample(client, methodCollection, serviceMethod, example, true, "ShortVersion"); + var mapping = sample.ParameterValueMapping; + + Assert.IsTrue(mapping.ContainsKey("message")); + Assert.IsNotNull(mapping["message"].Value); + } + + [Test] + public void ParameterMapping_MissingOptionalParam_IsOmitted() + { + 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"); + var mapping = sample.ParameterValueMapping; + + Assert.IsFalse(mapping.ContainsKey("tag")); + } + + [Test] + public void GetEndpointValue_WithoutExample_UsesPlaceholder() + { + var sample = CreateBasicSample("ShortVersion"); + var endpointValue = InvokeGetEndpointValue(sample, "endpoint"); + Assert.AreEqual("", GetRawExampleValue(endpointValue)); + } + + [Test] + public void ParameterMapping_TokenCredential_GeneratesNewInstanceExpression() + { + var sample = CreateSampleWithClientParameterType("credential", new CSharpType(typeof(TokenCredential))); + var mapping = sample.ParameterValueMapping; + + Assert.IsTrue(mapping.ContainsKey("credential")); + Assert.IsNull(mapping["credential"].Value); + var credentialExpression = UnwrapCast(ExampleValueExpressionBuilder.GetExpression(mapping["credential"])); + Assert.IsInstanceOf(credentialExpression); + + var newCredential = (NewInstanceExpression)credentialExpression; + Assert.AreEqual(typeof(TokenCredential), newCredential.Type?.FrameworkType); + Assert.AreEqual(0, newCredential.Parameters.Count); + } + + [Test] + public void ParameterMapping_AzureKeyCredential_GeneratesKeyPlaceholderExpression() + { + var sample = CreateSampleWithClientParameterType("credential", new CSharpType(typeof(AzureKeyCredential))); + var mapping = sample.ParameterValueMapping; + + Assert.IsTrue(mapping.ContainsKey("credential")); + Assert.IsNull(mapping["credential"].Value); + var credentialExpression = UnwrapCast(ExampleValueExpressionBuilder.GetExpression(mapping["credential"])); + Assert.IsInstanceOf(credentialExpression); + + var newCredential = (NewInstanceExpression)credentialExpression; + Assert.AreEqual(typeof(AzureKeyCredential), newCredential.Type?.FrameworkType); + Assert.AreEqual(1, newCredential.Parameters.Count); + Assert.IsNotInstanceOf(newCredential.Parameters[0]); + } + + [Test] + public void ParameterMapping_WaitUntil_UsesCompletedExpression() + { + var sample = CreateSampleWithClientParameterType("waitUntil", new CSharpType(typeof(WaitUntil))); + var mapping = sample.ParameterValueMapping; + + Assert.IsTrue(mapping.ContainsKey("waitUntil")); + Assert.IsNull(mapping["waitUntil"].Value); + + var expression = UnwrapCast(ExampleValueExpressionBuilder.GetExpression(mapping["waitUntil"])); + Assert.IsNotInstanceOf(expression); + } + + [Test] + public void ParameterMapping_RequiredRequestOptions_UsesNullExpression() + { + var sample = CreateSampleWithClientParameterType( + "options", + new CSharpType(typeof(RequestOptions)), + isOptional: false, + defaultValue: null); + var mapping = sample.ParameterValueMapping; + + Assert.IsTrue(mapping.ContainsKey("options")); + Assert.IsNull(mapping["options"].Value); + + var expression = UnwrapCast(ExampleValueExpressionBuilder.GetExpression(mapping["options"])); + Assert.IsInstanceOf(expression); + } + + [Test] + public void ParameterMapping_MatchConditions_UsesNullExpression() + { + var sample = CreateSampleWithClientParameterType("conditions", new CSharpType(typeof(MatchConditions))); + var mapping = sample.ParameterValueMapping; + + Assert.IsTrue(mapping.ContainsKey("conditions")); + Assert.IsNull(mapping["conditions"].Value); + + var expression = UnwrapCast(ExampleValueExpressionBuilder.GetExpression(mapping["conditions"])); + Assert.IsInstanceOf(expression); + } + + // ------------------------------------------------------------------- + // GetValueExpressionsForParameters + // ------------------------------------------------------------------- + + [Test] + public void GetValueExpressions_ProducesExpressions() + { + var bodyParam = InputFactory.MethodParameter("count", InputPrimitiveType.Int32, isRequired: true); + var example = new InputOperationExample( + "ShortVersion", + null, + [new InputParameterExample(bodyParam, InputExampleValue.Value(InputPrimitiveType.Int32, 42))], + ""); + + var operation = InputFactory.Operation("DoStuff", + parameters: [InputFactory.BodyParameter("count", InputPrimitiveType.Int32, isRequired: true)]); + var serviceMethod = InputFactory.BasicServiceMethod("DoStuff", operation, parameters: [bodyParam]); + var inputClient = InputFactory.Client("StuffClient", methods: [serviceMethod]); + + MockHelpers.LoadMockGenerator( + createCSharpTypeCore: (inputType) => new CSharpType(typeof(int))); + + var client = ScmCodeModelGenerator.Instance.TypeFactory.CreateClient(inputClient)!; + var methodCollection = new ScmMethodProviderCollection(serviceMethod, client); + + var sample = new OperationSample(client, methodCollection, serviceMethod, example, false, "ShortVersion"); + + var declarations = new List(); + var syncProtocol = methodCollection.MethodProviders + .FirstOrDefault(m => m.Kind == ScmMethodKind.Protocol && + !m.Signature.Modifiers.HasFlag(MethodSignatureModifiers.Async)); + + if (syncProtocol != null) + { + var expressions = sample.GetValueExpressionsForParameters( + syncProtocol.Signature.Parameters, declarations).ToList(); + + Assert.IsTrue(expressions.Count > 0); + } + } + + [Test] + public void GetEndpointValue_WithExample_UsesExampleValue() + { + const string endpointUrl = "https://example.contoso.test"; + var sample = CreateSampleWithEndpointExample("ShortVersion", endpointUrl); + var endpointValue = InvokeGetEndpointValue(sample, "endpoint"); + Assert.AreEqual(endpointUrl, GetRawExampleValue(endpointValue)); + } + + // ------------------------------------------------------------------- + // Sample information (human-readable descriptions) + // ------------------------------------------------------------------- + + [Test] + public void GetSampleInformation_Sync_Convenience() + { + var sample = CreateBasicSample("ShortVersion", isConvenience: true); + var info = sample.GetSampleInformation(false); + Assert.IsTrue(info.Contains("how to call")); + Assert.IsFalse(info.Contains("Async")); + } + + [Test] + public void GetSampleInformation_Async_AppendsAsync() + { + var sample = CreateBasicSample("ShortVersion", isConvenience: true); + var info = sample.GetSampleInformation(true); + Assert.IsTrue(info.Contains("Async")); + } + + [Test] + public void GetSampleInformation_AllParameters_IncludesAllParameters() + { + var sample = CreateBasicSample("AllParameters", isConvenience: true); + var info = sample.GetSampleInformation(false); + Assert.IsTrue(info.Contains("all parameters")); + } + + // ------------------------------------------------------------------- + // Static helper: ShouldGenerateSample + // ------------------------------------------------------------------- + + [Test] + public void ShouldGenerateSample_PublicMethod_ReturnsTrue() + { + var operation = InputFactory.Operation("TestOp"); + 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); + + var syncProtocol = methodCollection.MethodProviders + .FirstOrDefault(m => m.Kind == ScmMethodKind.Protocol && + !m.Signature.Modifiers.HasFlag(MethodSignatureModifiers.Async)); + + if (syncProtocol != null) + { + Assert.IsTrue(OperationSample.ShouldGenerateSample(client, syncProtocol.Signature)); + } + } + + [Test] + public void ShouldGenerateSample_SubClient_ReturnsTrue() + { + var (_, _, subProvider) = CreateSubClientSample("ShortVersion"); + + // Verify that subclients are identified correctly + Assert.IsTrue(subProvider.InputClient.Parent != null); + } + + // ------------------------------------------------------------------- + // Static helper: ShouldGenerateShortVersion + // ------------------------------------------------------------------- + + [Test] + public void ShouldGenerateShortVersion_NoConvenience_ReturnsTrue() + { + 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)); + } + + // ------------------------------------------------------------------- + // 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 CreatePagingSample(string exampleKey) + { + var operation = InputFactory.Operation("ListItems"); + var pagingMetadata = InputFactory.PagingMetadata(["items"], null, null); + var serviceMethod = InputFactory.PagingServiceMethod("ListItems", operation, pagingMetadata: pagingMetadata); + var inputClient = InputFactory.Client("PagingClient", 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, false, 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 CreateSubClientSampleWithEndpointExample(string exampleKey, string? endpointExample) + { + 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); + + var exampleParameters = endpointExample is null + ? new List() + : new List + { + new InputParameterExample(endpointParam, InputExampleValue.Value(InputPrimitiveType.Url, endpointExample)) + }; + + MockHelpers.LoadMockGenerator( + clients: () => [parentClient, subClient], + createCSharpTypeCore: inputType => inputType.Equals(InputPrimitiveType.Url) + ? new CSharpType(typeof(Uri)) + : new CSharpType(typeof(string))); + + var subProvider = ScmCodeModelGenerator.Instance.TypeFactory.CreateClient(subClient)!; + var methodCollection = new ScmMethodProviderCollection(subServiceMethod, subProvider); + var example = new InputOperationExample(exampleKey, null, exampleParameters, ""); + + return new OperationSample(subProvider, methodCollection, subServiceMethod, example, false, exampleKey); + } + + 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"); + } + + 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; + } + + 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/Providers/ScmMethodProviderCollectionTests.cs b/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/test/Providers/ScmMethodProviderCollectionTests.cs index 6bd6a7743c5..92a010ff8a2 100644 --- a/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/test/Providers/ScmMethodProviderCollectionTests.cs +++ b/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/test/Providers/ScmMethodProviderCollectionTests.cs @@ -6,10 +6,12 @@ using System.ClientModel.Primitives; using System.Collections.Generic; using System.Linq; +using System.Reflection; using System.Threading; using System.Threading.Tasks; using Microsoft.CodeAnalysis; using Microsoft.TypeSpec.Generator.ClientModel.Providers; +using Microsoft.TypeSpec.Generator.ClientModel.Providers.Samples; using Microsoft.TypeSpec.Generator.Input; using Microsoft.TypeSpec.Generator.Input.Extensions; using Microsoft.TypeSpec.Generator.Primitives; @@ -2139,5 +2141,82 @@ public void ConvenienceMethod_WithPublicParameterType_IsPublic() Assert.IsFalse(convenienceMethod.Signature.Modifiers.HasFlag(MethodSignatureModifiers.Internal)); } } + + [Test] + public void Samples_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 expectedCount = OperationSample.ShouldGenerateShortVersion(methodCollection) ? 4 : 3; + Assert.AreEqual(expectedCount, methodCollection.Samples.Count); + Assert.IsTrue(methodCollection.Samples.Any(s => !s.IsConvenienceSample && s.ExampleKey == "AllParameters")); + Assert.IsTrue(methodCollection.Samples.Any(s => s.IsConvenienceSample && s.ExampleKey == "AllParameters")); + Assert.IsTrue(methodCollection.Samples.Any(s => s.IsConvenienceSample && s.ExampleKey == "ShortVersion") || + !OperationSample.ShouldGenerateShortVersion(methodCollection)); + + if (OperationSample.ShouldGenerateShortVersion(methodCollection)) + { + Assert.IsTrue(methodCollection.Samples.Any(s => !s.IsConvenienceSample && s.ExampleKey == "ShortVersion")); + } + else + { + Assert.IsFalse(methodCollection.Samples.Any(s => !s.IsConvenienceSample && s.ExampleKey == "ShortVersion")); + } + } + + [Test] + public void Samples_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 methodCollection = new ScmMethodProviderCollection(serviceMethod, client); + + Assert.AreEqual(2, methodCollection.Samples.Count); + Assert.IsTrue(methodCollection.Samples.All(s => !s.IsConvenienceSample)); + } + + [Test] + public void Samples_WithoutExamples_ReturnsEmpty() + { + 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 methodCollection = new ScmMethodProviderCollection(serviceMethod, client); + + Assert.IsEmpty(methodCollection.Samples); + } + + 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/ScmKnownParametersTests.cs b/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/test/ScmKnownParametersTests.cs index 40e7c9e92bd..06b74024358 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; @@ -40,5 +41,17 @@ public void RepeatabilityFirstSentParamHasDefaultValue() var expectedDefaultValue = Static(typeof(DateTimeOffset)).Property(nameof(DateTimeOffset.Now)); Assert.AreEqual(expectedDefaultValue, parameter.DefaultValue); } + + [Test] + public void KeyCredentialHasExpectedType() + { + Assert.AreEqual("ApiKeyCredential", ScmKnownParameters.KeyCredential.Type.Name); + } + + [Test] + public void TokenCredentialHasExpectedType() + { + Assert.AreEqual("AuthenticationTokenProvider", ScmKnownParameters.TokenCredential.Type.Name); + } } } From 37a75fecba9384d6dc3b4017da8b5cf0a576c75e Mon Sep 17 00:00:00 2001 From: LazyLinh2 Date: Tue, 19 May 2026 14:26:49 -0700 Subject: [PATCH 02/12] Change TokenCredential to add DefaultAzureCredential for parity with autorest --- .../Samples/ExampleValueExpressionBuilder.cs | 379 +++++++++++++++++ .../src/Providers/Samples/OperationSample.cs | 12 +- .../Providers/Samples/OperationSampleTests.cs | 385 +++++------------- 3 files changed, 481 insertions(+), 295 deletions(-) create mode 100644 packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/src/Providers/Samples/ExampleValueExpressionBuilder.cs 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..a2c906c9080 --- /dev/null +++ b/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/src/Providers/Samples/ExampleValueExpressionBuilder.cs @@ -0,0 +1,379 @@ +// Copyright (c) Microsoft Corporation. All rights reserved. +// Licensed under the MIT License. + +using System; +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.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; + } + + // 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; + + // Access the enum member by name using the type reference + var rawString = rawValue.ToString()!; + // Use the type name as a static access point: EnumType.MemberName + return new MemberExpression(Static(enumType), rawString); + } + + 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; + + var valueExpr = GetExpressionForAnonymousObject(value); + properties[Identifier(key)] = 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 index 8e35ee9e267..9d8bdded510 100644 --- 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 @@ -146,7 +146,9 @@ private IReadOnlyList BuildClientInvocationChain() { var callChain = new Stack(); - // Walk from current client up to root, collecting factory methods + // 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) { @@ -337,12 +339,15 @@ private bool TryProcessKnownParameter(Dictionary } // TokenCredential — produce `new DefaultAzureCredential()` + // TokenCredential is abstract, so we must use a concrete type. if (type.Equals(ScmKnownParameters.TokenCredential.Type) || type.Name == ScmKnownParameters.TokenCredential.Type.Name || type.Name == "TokenCredential") { + // Use FormattableStringExpression because DefaultAzureCredential + // lives in Azure.Identity which the generator doesn't reference. result[parameter.Name] = new ExampleParameterValue( - parameter.Name, type, New.Instance(type)); + parameter.Name, type, new FormattableStringExpression("new DefaultAzureCredential()", [])); return true; } @@ -517,7 +522,8 @@ public IEnumerable GetValueExpressionsForParameters( if (ParameterValueMapping.TryGetValue(parameter.Name, out var exampleValue)) { - parameterExpression = ExampleValueExpressionBuilder.GetExpression(exampleValue); + var format = parameter.WireInfo?.SerializationFormat ?? SerializationFormat.Default; + parameterExpression = ExampleValueExpressionBuilder.GetExpression(exampleValue, format); } else { 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 index 0f753a9ebf9..dcec8a22bbf 100644 --- 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 @@ -5,13 +5,12 @@ using System.Linq; using System; using System.Reflection; -using System.ClientModel.Primitives; 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.Statements; +using Microsoft.TypeSpec.Generator.Snippets; using Microsoft.TypeSpec.Generator.Tests.Common; using NUnit.Framework; @@ -26,88 +25,71 @@ public void SetUp() } // ------------------------------------------------------------------- - // Core identity properties + // TokenCredential → new DefaultAzureCredential() // ------------------------------------------------------------------- [Test] - public void ExampleKey_PreservedFromInput() + public void TokenCredential_ProducesDefaultAzureCredential() { - var sample = CreateBasicSample("ShortVersion"); - Assert.AreEqual("ShortVersion", sample.ExampleKey); - } - - [Test] - public void IsAllParametersUsed_TrueForAllParameters() - { - var sample = CreateBasicSample("AllParameters"); - Assert.IsTrue(sample.IsAllParametersUsed); - } + var sample = CreateSampleWithClientParameterType("credential", new CSharpType(typeof(TokenCredential))); + var mapping = sample.ParameterValueMapping; - [Test] - public void IsAllParametersUsed_FalseForShortVersion() - { - var sample = CreateBasicSample("ShortVersion"); - Assert.IsFalse(sample.IsAllParametersUsed); - } + Assert.IsTrue(mapping.ContainsKey("credential")); - [Test] - public void IsConvenienceSample_PreservedFromInput() - { - var sample = CreateBasicSample("ShortVersion", isConvenience: true); - Assert.IsTrue(sample.IsConvenienceSample); - } + // 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); - [Test] - public void InputOperationName_PreservedFromServiceMethod() - { - var sample = CreateBasicSample("ShortVersion"); - Assert.AreEqual("TestOperation", sample.InputOperationName); - } - - [Test] - public void ResourceName_FallsBackToClientName() - { - var sample = CreateBasicSample("ShortVersion"); - // InputFactory.Operation sets ResourceName to null, - // so falls back to client name - Assert.AreEqual("TestClient", sample.ResourceName); + // 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)); } // ------------------------------------------------------------------- - // Operation type detection + // ApiKeyCredential → new AzureKeyCredential("") // ------------------------------------------------------------------- [Test] - public void IsPageable_FalseForBasicMethod() + public void ApiKeyCredential_ProducesNewWithKeyPlaceholder() { - var sample = CreateBasicSample("ShortVersion"); - Assert.IsFalse(sample.IsPageable); - } + var sample = CreateSampleWithClientParameterType("credential", new CSharpType(typeof(AzureKeyCredential))); + var mapping = sample.ParameterValueMapping; - [Test] - public void IsPageable_TrueForPagingMethod() - { - var operation = InputFactory.Operation("ListItems"); - var pagingMetadata = InputFactory.PagingMetadata(["items"], null, null); - var serviceMethod = InputFactory.PagingServiceMethod("ListItems", operation, pagingMetadata: pagingMetadata); + Assert.IsTrue(mapping.ContainsKey("credential")); - // Verify the service method is recognized as paging - Assert.IsInstanceOf(serviceMethod); + 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 IsLongRunning_FalseForBasicMethod() + public void Endpoint_WithoutExample_UsesPlaceholder() { var sample = CreateBasicSample("ShortVersion"); - Assert.IsFalse(sample.IsLongRunning); + var endpointValue = InvokeGetEndpointValue(sample, "endpoint"); + Assert.AreEqual("", GetRawExampleValue(endpointValue)); } [Test] - public void HasResponseBody_FalseForVoidReturn() + public void Endpoint_WithExample_UsesProvidedUrl() { - var sample = CreateBasicSample("ShortVersion"); - // Basic operation with no response type → no body - Assert.IsFalse(sample.HasResponseBody); + const string url = "https://example.contoso.test"; + var sample = CreateSampleWithEndpointExample("ShortVersion", url); + var endpointValue = InvokeGetEndpointValue(sample, "endpoint"); + Assert.AreEqual(url, GetRawExampleValue(endpointValue)); } // ------------------------------------------------------------------- @@ -115,7 +97,7 @@ public void HasResponseBody_FalseForVoidReturn() // ------------------------------------------------------------------- [Test] - public void ClientInvocationChain_RootClient_HasSingleConstructor() + public void RootClient_ChainHasConstructor() { var sample = CreateBasicSample("ShortVersion"); var chain = sample.ClientInvocationChain; @@ -129,22 +111,22 @@ public void ClientInvocationChain_RootClient_HasSingleConstructor() // ------------------------------------------------------------------- [Test] - public void ClientInvocationChain_SubClient_HasConstructorAndFactory() + public void SubClient_ChainHasConstructorThenFactory() { var (sample, _, _) = CreateSubClientSample("ShortVersion"); var chain = sample.ClientInvocationChain; Assert.IsTrue(chain.Count >= 2); - Assert.IsInstanceOf(chain[0]); - Assert.IsInstanceOf(chain[1]); + Assert.IsInstanceOf(chain[0], "First element should be root ctor"); + Assert.IsInstanceOf(chain[1], "Second element should be factory method"); } // ------------------------------------------------------------------- - // Parameter value mapping + // Parameter mapping // ------------------------------------------------------------------- [Test] - public void ParameterMapping_SpecProvidedValue_IsMapped() + public void ParameterMapping_ExampleValue_IsMapped() { var bodyParam = InputFactory.MethodParameter("message", InputPrimitiveType.String, isRequired: true); var example = new InputOperationExample( @@ -163,17 +145,19 @@ [new InputParameterExample(bodyParam, InputExampleValue.Value(InputPrimitiveType var client = ScmCodeModelGenerator.Instance.TypeFactory.CreateClient(inputClient)!; var methodCollection = new ScmMethodProviderCollection(serviceMethod, client); - - // Use convenience sample so the parameter name "message" is preserved var sample = new OperationSample(client, methodCollection, serviceMethod, example, true, "ShortVersion"); - var mapping = sample.ParameterValueMapping; + var mapping = sample.ParameterValueMapping; Assert.IsTrue(mapping.ContainsKey("message")); Assert.IsNotNull(mapping["message"].Value); } + // ------------------------------------------------------------------- + // Optional params excluded from ShortVersion + // ------------------------------------------------------------------- + [Test] - public void ParameterMapping_MissingOptionalParam_IsOmitted() + public void ParameterMapping_OptionalParam_ExcludedFromShortVersion() { var optionalParam = InputFactory.MethodParameter("tag", InputPrimitiveType.String, isRequired: false, defaultValue: InputFactory.Constant.String("default")); @@ -189,226 +173,98 @@ public void ParameterMapping_MissingOptionalParam_IsOmitted() 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.IsFalse(mapping.ContainsKey("tag")); - } - [Test] - public void GetEndpointValue_WithoutExample_UsesPlaceholder() - { - var sample = CreateBasicSample("ShortVersion"); - var endpointValue = InvokeGetEndpointValue(sample, "endpoint"); - Assert.AreEqual("", GetRawExampleValue(endpointValue)); + Assert.IsFalse(sample.ParameterValueMapping.ContainsKey("tag")); } - [Test] - public void ParameterMapping_TokenCredential_GeneratesNewInstanceExpression() - { - var sample = CreateSampleWithClientParameterType("credential", new CSharpType(typeof(TokenCredential))); - var mapping = sample.ParameterValueMapping; - - Assert.IsTrue(mapping.ContainsKey("credential")); - Assert.IsNull(mapping["credential"].Value); - var credentialExpression = UnwrapCast(ExampleValueExpressionBuilder.GetExpression(mapping["credential"])); - Assert.IsInstanceOf(credentialExpression); - - var newCredential = (NewInstanceExpression)credentialExpression; - Assert.AreEqual(typeof(TokenCredential), newCredential.Type?.FrameworkType); - Assert.AreEqual(0, newCredential.Parameters.Count); - } - - [Test] - public void ParameterMapping_AzureKeyCredential_GeneratesKeyPlaceholderExpression() - { - var sample = CreateSampleWithClientParameterType("credential", new CSharpType(typeof(AzureKeyCredential))); - var mapping = sample.ParameterValueMapping; - - Assert.IsTrue(mapping.ContainsKey("credential")); - Assert.IsNull(mapping["credential"].Value); - var credentialExpression = UnwrapCast(ExampleValueExpressionBuilder.GetExpression(mapping["credential"])); - Assert.IsInstanceOf(credentialExpression); - - var newCredential = (NewInstanceExpression)credentialExpression; - Assert.AreEqual(typeof(AzureKeyCredential), newCredential.Type?.FrameworkType); - Assert.AreEqual(1, newCredential.Parameters.Count); - Assert.IsNotInstanceOf(newCredential.Parameters[0]); - } + // ------------------------------------------------------------------- + // WaitUntil → .Completed + // ------------------------------------------------------------------- [Test] - public void ParameterMapping_WaitUntil_UsesCompletedExpression() + public void WaitUntil_ProducesCompletedMemberAccess() { var sample = CreateSampleWithClientParameterType("waitUntil", new CSharpType(typeof(WaitUntil))); var mapping = sample.ParameterValueMapping; Assert.IsTrue(mapping.ContainsKey("waitUntil")); - Assert.IsNull(mapping["waitUntil"].Value); - - var expression = UnwrapCast(ExampleValueExpressionBuilder.GetExpression(mapping["waitUntil"])); - Assert.IsNotInstanceOf(expression); + var expr = UnwrapCast(ExampleValueExpressionBuilder.GetExpression(mapping["waitUntil"])); + // Should be a property access like WaitUntil.Completed + Assert.IsInstanceOf(expr); } + // ------------------------------------------------------------------- + // RequestOptions (required) → null + // ------------------------------------------------------------------- + [Test] - public void ParameterMapping_RequiredRequestOptions_UsesNullExpression() + public void RequiredRequestOptions_ProducesNull() { var sample = CreateSampleWithClientParameterType( "options", - new CSharpType(typeof(RequestOptions)), + new CSharpType(typeof(System.ClientModel.Primitives.RequestOptions)), isOptional: false, defaultValue: null); var mapping = sample.ParameterValueMapping; Assert.IsTrue(mapping.ContainsKey("options")); - Assert.IsNull(mapping["options"].Value); - - var expression = UnwrapCast(ExampleValueExpressionBuilder.GetExpression(mapping["options"])); - Assert.IsInstanceOf(expression); + var expr = UnwrapCast(ExampleValueExpressionBuilder.GetExpression(mapping["options"])); + Assert.IsInstanceOf(expr); } + // ------------------------------------------------------------------- + // MatchConditions → null + // ------------------------------------------------------------------- + [Test] - public void ParameterMapping_MatchConditions_UsesNullExpression() + public void MatchConditions_ProducesNull() { var sample = CreateSampleWithClientParameterType("conditions", new CSharpType(typeof(MatchConditions))); var mapping = sample.ParameterValueMapping; Assert.IsTrue(mapping.ContainsKey("conditions")); - Assert.IsNull(mapping["conditions"].Value); - - var expression = UnwrapCast(ExampleValueExpressionBuilder.GetExpression(mapping["conditions"])); - Assert.IsInstanceOf(expression); + var expr = UnwrapCast(ExampleValueExpressionBuilder.GetExpression(mapping["conditions"])); + Assert.IsInstanceOf(expr); } // ------------------------------------------------------------------- - // GetValueExpressionsForParameters + // ShouldGenerateShortVersion // ------------------------------------------------------------------- [Test] - public void GetValueExpressions_ProducesExpressions() + public void ShouldGenerateShortVersion_TrueWhenNoConvenience() { - var bodyParam = InputFactory.MethodParameter("count", InputPrimitiveType.Int32, isRequired: true); - var example = new InputOperationExample( - "ShortVersion", - null, - [new InputParameterExample(bodyParam, InputExampleValue.Value(InputPrimitiveType.Int32, 42))], - ""); - - var operation = InputFactory.Operation("DoStuff", - parameters: [InputFactory.BodyParameter("count", InputPrimitiveType.Int32, isRequired: true)]); - var serviceMethod = InputFactory.BasicServiceMethod("DoStuff", operation, parameters: [bodyParam]); - var inputClient = InputFactory.Client("StuffClient", methods: [serviceMethod]); - - MockHelpers.LoadMockGenerator( - createCSharpTypeCore: (inputType) => new CSharpType(typeof(int))); + 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); - var sample = new OperationSample(client, methodCollection, serviceMethod, example, false, "ShortVersion"); - - var declarations = new List(); - var syncProtocol = methodCollection.MethodProviders - .FirstOrDefault(m => m.Kind == ScmMethodKind.Protocol && - !m.Signature.Modifiers.HasFlag(MethodSignatureModifiers.Async)); - - if (syncProtocol != null) - { - var expressions = sample.GetValueExpressionsForParameters( - syncProtocol.Signature.Parameters, declarations).ToList(); - - Assert.IsTrue(expressions.Count > 0); - } - } - - [Test] - public void GetEndpointValue_WithExample_UsesExampleValue() - { - const string endpointUrl = "https://example.contoso.test"; - var sample = CreateSampleWithEndpointExample("ShortVersion", endpointUrl); - var endpointValue = InvokeGetEndpointValue(sample, "endpoint"); - Assert.AreEqual(endpointUrl, GetRawExampleValue(endpointValue)); + Assert.IsTrue(OperationSample.ShouldGenerateShortVersion(methodCollection)); } // ------------------------------------------------------------------- - // Sample information (human-readable descriptions) + // Sample metadata // ------------------------------------------------------------------- [Test] - public void GetSampleInformation_Sync_Convenience() + public void SampleInformation_ContainsMethodName() { var sample = CreateBasicSample("ShortVersion", isConvenience: true); var info = sample.GetSampleInformation(false); Assert.IsTrue(info.Contains("how to call")); - Assert.IsFalse(info.Contains("Async")); } [Test] - public void GetSampleInformation_Async_AppendsAsync() + public void SampleInformation_AsyncAppendsAsync() { var sample = CreateBasicSample("ShortVersion", isConvenience: true); var info = sample.GetSampleInformation(true); Assert.IsTrue(info.Contains("Async")); } - [Test] - public void GetSampleInformation_AllParameters_IncludesAllParameters() - { - var sample = CreateBasicSample("AllParameters", isConvenience: true); - var info = sample.GetSampleInformation(false); - Assert.IsTrue(info.Contains("all parameters")); - } - - // ------------------------------------------------------------------- - // Static helper: ShouldGenerateSample - // ------------------------------------------------------------------- - - [Test] - public void ShouldGenerateSample_PublicMethod_ReturnsTrue() - { - var operation = InputFactory.Operation("TestOp"); - 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); - - var syncProtocol = methodCollection.MethodProviders - .FirstOrDefault(m => m.Kind == ScmMethodKind.Protocol && - !m.Signature.Modifiers.HasFlag(MethodSignatureModifiers.Async)); - - if (syncProtocol != null) - { - Assert.IsTrue(OperationSample.ShouldGenerateSample(client, syncProtocol.Signature)); - } - } - - [Test] - public void ShouldGenerateSample_SubClient_ReturnsTrue() - { - var (_, _, subProvider) = CreateSubClientSample("ShortVersion"); - - // Verify that subclients are identified correctly - Assert.IsTrue(subProvider.InputClient.Parent != null); - } - - // ------------------------------------------------------------------- - // Static helper: ShouldGenerateShortVersion - // ------------------------------------------------------------------- - - [Test] - public void ShouldGenerateShortVersion_NoConvenience_ReturnsTrue() - { - 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)); - } - // ------------------------------------------------------------------- // Helpers // ------------------------------------------------------------------- @@ -426,20 +282,6 @@ private static OperationSample CreateBasicSample(string exampleKey, bool isConve return new OperationSample(client, methodCollection, serviceMethod, example, isConvenience, exampleKey); } - private static OperationSample CreatePagingSample(string exampleKey) - { - var operation = InputFactory.Operation("ListItems"); - var pagingMetadata = InputFactory.PagingMetadata(["items"], null, null); - var serviceMethod = InputFactory.PagingServiceMethod("ListItems", operation, pagingMetadata: pagingMetadata); - var inputClient = InputFactory.Client("PagingClient", 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, false, exampleKey); - } - private static (OperationSample sample, ClientProvider rootClient, ClientProvider subClient) CreateSubClientSample(string exampleKey) { var endpointParam = InputFactory.EndpointParameter("endpoint", InputPrimitiveType.Url, isRequired: true); @@ -461,38 +303,6 @@ private static (OperationSample sample, ClientProvider rootClient, ClientProvide return (sample, rootProvider, subProvider); } - private static OperationSample CreateSubClientSampleWithEndpointExample(string exampleKey, string? endpointExample) - { - 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); - - var exampleParameters = endpointExample is null - ? new List() - : new List - { - new InputParameterExample(endpointParam, InputExampleValue.Value(InputPrimitiveType.Url, endpointExample)) - }; - - MockHelpers.LoadMockGenerator( - clients: () => [parentClient, subClient], - createCSharpTypeCore: inputType => inputType.Equals(InputPrimitiveType.Url) - ? new CSharpType(typeof(Uri)) - : new CSharpType(typeof(string))); - - var subProvider = ScmCodeModelGenerator.Instance.TypeFactory.CreateClient(subClient)!; - var methodCollection = new ScmMethodProviderCollection(subServiceMethod, subProvider); - var example = new InputOperationExample(exampleKey, null, exampleParameters, ""); - - return new OperationSample(subProvider, methodCollection, subServiceMethod, example, false, exampleKey); - } - private static OperationSample CreateSampleWithEndpointExample(string exampleKey, string endpointExample) { var endpointParam = InputFactory.EndpointParameter("endpoint", InputPrimitiveType.Url, isRequired: true); @@ -539,22 +349,14 @@ private static OperationSample CreateSampleWithClientParameterType( return new OperationSample(client, methodCollection, serviceMethod, example, false, "ShortVersion"); } - private sealed class TokenCredential - { - } - - private sealed class AzureKeyCredential - { - } - + // 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 sealed class MatchConditions { } private static object? GetRawExampleValue(InputExampleValue value) { @@ -565,21 +367,20 @@ private sealed class MatchConditions 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!; } } From 18188f3d42af1583ff0f1d0bc62cd264307159f6 Mon Sep 17 00:00:00 2001 From: LazyLinh2 Date: Tue, 19 May 2026 15:27:07 -0700 Subject: [PATCH 03/12] fix spelling --- .../src/Providers/Samples/OperationSample.cs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) 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 index 9d8bdded510..292a1882acc 100644 --- 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 @@ -681,7 +681,7 @@ public static bool ShouldGenerateShortVersion(ScmMethodProviderCollection method 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 identica. + // 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))) { From 002eabc11036fc704116865ec2e2887c2491fc6d Mon Sep 17 00:00:00 2001 From: LazyLinh2 Date: Tue, 26 May 2026 14:16:20 -0700 Subject: [PATCH 04/12] Change to ScmOutputLibrary and ScmMethodProviderCollection to allow for sample generation on sample client --- .../Providers/Samples/ClientSampleProvider.cs | 523 +++ .../Samples/ExampleValueExpressionBuilder.cs | 43 +- .../src/Providers/Samples/OperationSample.cs | 23 +- .../Providers/ScmMethodProviderCollection.cs | 20 +- .../src/ScmOutputLibrary.cs | 36 + .../Samples/ClientSampleProviderTests.cs | 286 ++ .../ScmMethodProviderCollectionTests.cs | 5 +- .../src/InputTypes/InputPrimitiveType.cs | 6 +- .../src/Samples/ExampleMockValueBuilder.cs | 241 ++ .../Samples/ExampleMockValueBuilderTests.cs | 546 +++ .../Samples/Samples_SampleTypeSpecClient.cs | 3370 +++++++++++++++++ .../Local/Sample-TypeSpec/tspCodeModel.json | 1931 +++------- 12 files changed, 5612 insertions(+), 1418 deletions(-) create mode 100644 packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/src/Providers/Samples/ClientSampleProvider.cs create mode 100644 packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/test/Providers/Samples/ClientSampleProviderTests.cs create mode 100644 packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator/src/Samples/ExampleMockValueBuilder.cs create mode 100644 packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator/test/Samples/ExampleMockValueBuilderTests.cs create mode 100644 packages/http-client-csharp/generator/TestProjects/Local/Sample-TypeSpec/tests/Generated/Samples/Samples_SampleTypeSpecClient.cs 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..17bdd5b3e68 --- /dev/null +++ b/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/src/Providers/Samples/ClientSampleProvider.cs @@ -0,0 +1,523 @@ +// 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.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 methodCollection.Samples) + { + methods.Add(BuildSampleMethod(sample, isAsync: false)); + methods.Add(BuildSampleMethod(sample, isAsync: true)); + } + } + + return [.. methods]; + } + + // ------------------------------------------------------------------- + // 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/ExampleValueExpressionBuilder.cs b/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/src/Providers/Samples/ExampleValueExpressionBuilder.cs index a2c906c9080..0c7512f047a 100644 --- 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 @@ -2,6 +2,7 @@ // Licensed under the MIT License. using System; +using System.ClientModel; using System.Collections.Generic; using System.IO; using System.Linq; @@ -9,6 +10,7 @@ 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; @@ -167,6 +169,13 @@ private static ValueExpression GetExpressionForFrameworkType(Type frameworkType, 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)) { @@ -237,10 +246,32 @@ private static ValueExpression GetExpressionForEnum(CSharpType enumType, InputEx if (rawValue == null) return Default; - // Access the enum member by name using the type reference - var rawString = rawValue.ToString()!; - // Use the type name as a static access point: EnumType.MemberName - return new MemberExpression(Static(enumType), rawString); + // 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) @@ -326,8 +357,10 @@ internal static ValueExpression GetExpressionForAnonymousObject(InputExampleValu 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(key)] = valueExpr; + properties[Identifier(safeKey)] = valueExpr; } return properties.Count > 0 ? New.Anonymous(properties) : New.Instance(typeof(object)); } 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 index 292a1882acc..0d36a0ee2ba 100644 --- 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 @@ -301,8 +301,7 @@ private bool TryProcessKnownParameter(Dictionary return true; } - // Endpoint (Uri) — use provided example value, otherwise a named placeholder like "" - if (type.Equals(typeof(Uri)) && parameter.InputParameter is InputEndpointParameter) + 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); @@ -351,8 +350,11 @@ private bool TryProcessKnownParameter(Dictionary return true; } - // ClientOptions — skip (optional, not needed in sample) - if (parameter.Name.EndsWith("Options", StringComparison.OrdinalIgnoreCase) && parameter.DefaultValue != null) + // 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; } @@ -518,6 +520,15 @@ public IEnumerable GetValueExpressionsForParameters( { 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)) @@ -527,8 +538,8 @@ public IEnumerable GetValueExpressionsForParameters( } else { - // No example value — skip optional, use default for required - if (parameter.DefaultValue != null) + // No example value — skip optional parameters (those with defaults or initialization values) + if (parameter.DefaultValue != null || parameter.InitializationValue != null) continue; parameterExpression = DefaultOf(parameter.Type); diff --git a/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/src/Providers/ScmMethodProviderCollection.cs b/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/src/Providers/ScmMethodProviderCollection.cs index e29cbc549b9..00e60528a92 100644 --- a/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/src/Providers/ScmMethodProviderCollection.cs +++ b/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/src/Providers/ScmMethodProviderCollection.cs @@ -20,6 +20,7 @@ using Microsoft.TypeSpec.Generator.Input; using Microsoft.TypeSpec.Generator.Primitives; using Microsoft.TypeSpec.Generator.Providers; +using Microsoft.TypeSpec.Generator.Samples; using Microsoft.TypeSpec.Generator.Snippets; using Microsoft.TypeSpec.Generator.Statements; using Microsoft.TypeSpec.Generator.Utilities; @@ -113,11 +114,6 @@ protected virtual IReadOnlyList BuildMethods() protected virtual IReadOnlyList BuildSamples() { - if (ServiceMethod.Operation.Examples.Count == 0) - { - return []; - } - var protocolMethod = MethodProviders.FirstOrDefault(m => m.Kind == ScmMethodKind.Protocol && !m.Signature.Modifiers.HasFlag(MethodSignatureModifiers.Async)); @@ -127,14 +123,24 @@ protected virtual IReadOnlyList BuildSamples() return []; } - bool shouldGenerateShortVersion = OperationSample.ShouldGenerateShortVersion(this); bool shouldGenerateConvenienceSamples = 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(this); + List samples = new(); - foreach (var example in ServiceMethod.Operation.Examples) + foreach (var example in examples) { if (!shouldGenerateShortVersion && example.Name == "ShortVersion") { 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..27282365bbd --- /dev/null +++ b/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/test/Providers/Samples/ClientSampleProviderTests.cs @@ -0,0 +1,286 @@ +// 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"); + } + } + + // ------------------------------------------------------------------- + // 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/ScmMethodProviderCollectionTests.cs b/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/test/Providers/ScmMethodProviderCollectionTests.cs index 92a010ff8a2..8006a9c54ac 100644 --- a/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/test/Providers/ScmMethodProviderCollectionTests.cs +++ b/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/test/Providers/ScmMethodProviderCollectionTests.cs @@ -2197,7 +2197,7 @@ public void Samples_DoesNotAttachConvenienceSamplesWhenConvenienceMethodIsDisabl } [Test] - public void Samples_WithoutExamples_ReturnsEmpty() + public void Samples_WithoutExamples_SynthesizesDefault() { var operation = InputFactory.Operation("GetWidget"); var serviceMethod = InputFactory.BasicServiceMethod("GetWidget", operation); @@ -2208,7 +2208,8 @@ public void Samples_WithoutExamples_ReturnsEmpty() var client = ScmCodeModelGenerator.Instance.TypeFactory.CreateClient(inputClient)!; var methodCollection = new ScmMethodProviderCollection(serviceMethod, client); - Assert.IsEmpty(methodCollection.Samples); + Assert.IsNotEmpty(methodCollection.Samples); + Assert.IsTrue(methodCollection.Samples.Any(s => s.ExampleKey == "ShortVersion")); } private static void SetOperationExamples(InputOperation operation, IReadOnlyList examples) 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/src/Samples/ExampleMockValueBuilder.cs b/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator/src/Samples/ExampleMockValueBuilder.cs new file mode 100644 index 00000000000..186d3d448ed --- /dev/null +++ b/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator/src/Samples/ExampleMockValueBuilder.cs @@ -0,0 +1,241 @@ +// 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) + { + bool hasOptionalParameters = operation.Parameters.Any(p => !p.IsRequired); + + if (!hasOptionalParameters) + { + return new[] { BuildOperationExample(operation, AllParametersKey, useAllParameters: true) }; + } + + return new[] + { + 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/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..86548f426a7 --- /dev/null +++ b/packages/http-client-csharp/generator/TestProjects/Local/Sample-TypeSpec/tests/Generated/Samples/Samples_SampleTypeSpecClient.cs @@ -0,0 +1,3370 @@ +// 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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_UpdateXmlAdvancedModel_AllParameters() + { + 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, + optionalString = "", + optionalInt = 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 = "", + optionalRecordUnknown = new + { + key = "" + }, + fixedEnum = "1", + extensibleEnum = "1", + optionalFixedEnum = 1, + optionalExtensibleEnum = 1, + label = "