text:
macro_rules! diesel_internal_expr_conversion {
    ($e:expr) => { $e }
}

#[macro_export]
#[doc(hidden)]
macro_rules! column {
    ($($table:ident)::*, $column_name:ident -> $Type:ty) => {
        #[allow(non_camel_case_types, dead_code)]
        #[derive(Debug, Clone, Copy)]
        pub struct $column_name;

        impl $crate::expression::Expression for $column_name {
            type SqlType = $Type;
        }

        impl<DB> $crate::query_builder::QueryFragment<DB> for $column_name where
            DB: $crate::backend::Backend,
        {
            fn to_sql(&self, out: &mut DB::QueryBuilder) -> $crate::query_builder::BuildQueryResult {
                try!(out.push_identifier($($table)::*::name()));
                out.push_sql(".");
                out.push_identifier(stringify!($column_name))
            }
        }

        impl $crate::expression::SelectableExpression<$($table)::*> for $column_name {}

        impl<'a, ST, Left, Right> SelectableExpression<
            $crate::WithQuerySource<'a, Left, Right>, ST> for $column_name where
            $column_name: SelectableExpression<Left, ST>
        {
        }

        impl $crate::expression::NonAggregate for $column_name {}

        impl $crate::query_source::Column for $column_name {
            type Table = $($table)::*;

            fn name() -> &'static str {
                stringify!($column_name)
            }
        }
    }
}

/// Specifies that a table exists, and what columns it has. This will create a
/// new public module, with the same name, as the name of the table. In this
/// module, you'll find a unit struct named `table`, and a unit struct with the
/// names of each of the columns. In the definition, you can also specify an
/// additional set of columns which exist, but should not be selected by default
/// (for example, for things like full text search)
///
/// Example usage
/// -------------
///
/// ```rust
/// # #[macro_use] extern crate diesel;
/// table! {
///     users {
///         id -> Integer,
///         name -> VarChar,
///         favorite_color -> Nullable<VarChar>,
///     }
/// }
/// # fn main() {}
/// ```
///
/// More complex usage:
///
/// ```rust
/// # #[macro_use] extern crate diesel;
/// table! {
///     users (non_standard_primary_key) {
///         non_standard_primary_key -> Integer,
///         name -> VarChar,
///         favorite_color -> Nullable<VarChar>,
///     } no select {
///         complex_index_column -> Text,
///     }
/// }
/// # fn main() {}
/// ```
///
/// This module will also contain several helper types:
///
/// dsl
/// ---
///
/// This simply re-exports the table, renamed to the same name as the module,
/// and each of the columns. This is useful to glob import when you're dealing
/// primarily with one table, to allow writing `users.filter(name.eq("Sean"))`
/// instead of `users::table.filter(users::name.eq("Sean"))`.
///
/// all_columns
/// -----------
///
/// A constant will be assigned called `all_columns`, which will be a tuple of
/// all the columns that aren't in the "no select" group. This is what will be
/// selected if you don't otherwise specify a select clause. It's type will be
/// `table::AllColumns`. You can also get this value from the
/// `Table::all_columns` function.
///
/// star
/// ----
///
/// This will be the qualified "star" expression for this table (e.g.
/// `users.*`). Internally, we read columns by index, not by name, so this
/// column is not safe to read data out of, and it has had it's SQL type set to
/// `()` to prevent accidentally using it as such. It is sometimes useful for
/// count statements however. It can also be accessed through the `Table.star()`
/// method.
#[macro_export]
macro_rules! table {
    (
        $name:ident {
            $($column_name:ident -> $Type:ty,)+
        }
    ) => {
        table! {
            $name (id) {
                $($column_name -> $Type,)+
            }
        }
    };
    (
        $name:ident ($pk:ident) {
            $($column_name:ident -> $Type:ty,)+
        }
    ) => {
        table! {
            $name ($pk) {
                $($column_name -> $Type,)+
            } no select {}
        }
    };
    (
        $name:ident {
            $($column_name:ident -> $Type:ty,)+
        } no select {
            $($no_select_column_name:ident -> $no_select_type:ty,)*
        }
    ) => {
        table! {
            $name (id) {
                $($column_name -> $Type,)+
            } no select {
                $($no_select_column_name -> $no_select_type,)*
            }
        }
    };
    (
        $name:ident ($pk:ident) {
            $($column_name:ident -> $Type:ty,)+
        } no select {
            $($no_select_column_name:ident -> $no_select_type:ty,)*
        }
    ) => {
        table_body! {
            $name ($pk) {
                $($column_name -> $Type,)+
            } no select {
                $($no_select_column_name -> $no_select_type,)*
            }
        }
    }
}

#[macro_export]
#[doc(hidden)]
macro_rules! table_body {
    (
        $name:ident ($pk:ident) {
            $($column_name:ident -> $Type:ty,)+
        } no select {
            $($no_select_column_name:ident -> $no_select_type:ty,)*
        }
    ) => {
        pub mod $name {
            use $crate::{
                QuerySource,
                Table,
            };
            use $crate::query_builder::*;
            use $crate::query_builder::nodes::Identifier;
            use $crate::types::*;
            pub use self::columns::*;

            pub mod dsl {
                pub use super::columns::{$($column_name),+};
                pub use super::table as $name;
            }

            #[allow(non_upper_case_globals, dead_code)]
            pub const all_columns: ($($column_name),+) = ($($column_name),+);

            #[allow(non_camel_case_types)]
            #[derive(Clone, Copy)]
            pub struct table;

            impl table {
                #[allow(dead_code)]
                pub fn star(&self) -> star {
                    star
                }
            }

            pub type SqlType = ($($Type),+);

            impl QuerySource for table {
                type FromClause = Identifier<'static>;

                fn from_clause(&self) -> Self::FromClause {
                    Identifier(stringify!($name))
                }
            }

            impl AsQuery for table {
                type SqlType = SqlType;
                type Query = SelectStatement<SqlType, ($($column_name),+), Self>;

                fn as_query(self) -> Self::Query {
                    SelectStatement::simple(all_columns, self)
                }
            }

            impl Table for table {
                type PrimaryKey = columns::$pk;
                type AllColumns = ($($column_name),+);

                fn name() -> &'static str {
                    stringify!($name)
                }

                fn primary_key(&self) -> Self::PrimaryKey {
                    columns::$pk
                }

                fn all_columns() -> Self::AllColumns {
                    ($($column_name),+)
                }
            }

            pub mod columns {
                use super::table;
                use $crate::{Table, Column, Expression, SelectableExpression};
                use $crate::backend::Backend;
                use $crate::query_builder::{QueryBuilder, BuildQueryResult, QueryFragment};
                use $crate::types::*;

                #[allow(non_camel_case_types, dead_code)]
                #[derive(Debug, Clone, Copy)]
                pub struct star;

                impl Expression for star {
                    type SqlType = ();
                }

                impl<DB: Backend> QueryFragment<DB> for star {
                    fn to_sql(&self, out: &mut DB::QueryBuilder) -> BuildQueryResult {
                        try!(out.push_identifier(table::name()));
                        out.push_sql(".*");
                        Ok(())
                    }
                }

                impl SelectableExpression<table> for star {}

                $(column!(table, $column_name -> $Type);)+
                $(column!(table, $no_select_column_name -> $no_select_type);)*
            }
        }
    }
}

#[macro_export]
#[doc(hidden)]
macro_rules! joinable {
    ($child:ident -> $parent:ident ($source:ident)) => {
        joinable_inner!($child::table => $parent::table : ($child::$source = $parent::table));
        joinable_inner!($parent::table => $child::table : ($child::$source = $parent::table));
    }
}

#[macro_export]
#[doc(hidden)]
macro_rules! joinable_inner {
    ($left_table:path => $right_table:path : ($foreign_key:path = $parent_table:path)) => {
        impl<JoinType> $crate::JoinTo<$right_table, JoinType> for $left_table {
            type JoinClause = $crate::query_builder::nodes::Join<
                <$left_table as $crate::QuerySource>::FromClause,
                <$right_table as $crate::QuerySource>::FromClause,
                $crate::expression::helper_types::Eq<
                    $crate::expression::nullable::Nullable<$foreign_key>,
                    $crate::expression::nullable::Nullable<
                        <$parent_table as $crate::query_source::Table>::PrimaryKey>,
                >,
                JoinType,
            >;

            fn join_clause(&self, join_type: JoinType) -> Self::JoinClause {
                use $crate::QuerySource;

                $crate::query_builder::nodes::Join::new(
                    self.from_clause(),
                    $right_table.from_clause(),
                    $foreign_key.nullable().eq($parent_table.primary_key().nullable()),
                    join_type,
                )
            }
        }
    }
}

#[macro_export]
#[doc(hidden)]
macro_rules! select_column_workaround {
    ($parent:ident -> $child:ident ($($column_name:ident),+)) => {
        $(select_column_inner!($parent -> $child $column_name);)+
        select_column_inner!($parent -> $child star);
    }
}

#[macro_export]
#[doc(hidden)]
macro_rules! select_column_inner {
    ($parent:ident -> $child:ident $column_name:ident) => {
        impl $crate::expression::SelectableExpression<
            $crate::query_source::InnerJoinSource<$child::table, $parent::table>,
        > for $parent::$column_name
        {
        }

        impl $crate::expression::SelectableExpression<
            $crate::query_source::InnerJoinSource<$parent::table, $child::table>,
        > for $parent::$column_name
        {
        }

        impl $crate::expression::SelectableExpression<
            $crate::query_source::LeftOuterJoinSource<$child::table, $parent::table>,
            <<$parent::$column_name as $crate::Expression>::SqlType
                as $crate::types::IntoNullable>::Nullable,
        > for $parent::$column_name
        {
        }

        impl $crate::expression::SelectableExpression<
            $crate::query_source::LeftOuterJoinSource<$parent::table, $child::table>,
        > for $parent::$column_name
        {
        }
    }
}

#[macro_export]
#[doc(hidden)]
macro_rules! join_through {
    ($parent:ident -> $through:ident -> $child:ident) => {
        impl<JoinType: Copy> $crate::JoinTo<$child::table, JoinType> for $parent::table {
            type JoinClause = <
                <$parent::table as $crate::JoinTo<$through::table, JoinType>>::JoinClause
                as $crate::query_builder::nodes::CombinedJoin<
                    <$through::table as $crate::JoinTo<$child::table, JoinType>>::JoinClause,
                >>::Output;

            fn join_clause(&self, join_type: JoinType) -> Self::JoinClause {
                use $crate::query_builder::nodes::CombinedJoin;
                let parent_to_through = $crate::JoinTo::<$through::table, JoinType>
                    ::join_clause(&$parent::table, join_type);
                let through_to_child = $crate::JoinTo::<$child::table, JoinType>
                    ::join_clause(&$through::table, join_type);
                parent_to_through.combine_with(through_to_child)
            }
        }
    }
}

/// Takes a query QueryFragment expression as an argument and returns a string
/// of SQL with placeholders for the dynamic values.
///
/// # Example
///
/// ### Returning SQL from a count statment:
/// #
/// # ```rust
/// # // example requires setup for users table
/// # use diesel::users::dsl::*;
/// # use diesel::query_builder::QueryFragment;
/// #
/// # fn main() {
/// let sql = debug_sql!(users.count());
/// assert_eq!(sql, "SELECT COUNT(*) FROM users");
/// # }
/// # ```
#[macro_export]
macro_rules! debug_sql {
    ($query:expr) => {{
        use $crate::query_builder::QueryFragment;
        use $crate::query_builder::debug::DebugQueryBuilder;
        let mut query_builder = DebugQueryBuilder::new();
        QueryFragment::<$crate::backend::Debug>::to_sql(&$query, &mut query_builder).unwrap();
        query_builder.sql
    }};
}

/// Takes takes a query QueryFragment expression as an argument and prints out
/// the SQL with placeholders for the dynamic values.
///
/// # Example
///
/// ### Printing SQL from a count statment:
/// #
/// # ```rust
/// # // example requires setup for users table
/// # use diesel::users::dsl::*;
/// # use diesel::query_builder::QueryFragment;
/// #
/// # fn main() {
/// print_sql!(users.count());
/// # }
/// # ```
#[macro_export]
macro_rules! print_sql {
    ($query:expr) => {
        println!("{}", &debug_sql!($query));
    };
}


text:
#ifndef NEK_TYPE_TRAITS_HAS_ITERATOR_HPP
#define NEK_TYPE_TRAITS_HAS_ITERATOR_HPP

#include <nek/type_traits/integral_constant.hpp>
#include <nek/type_traits/void_t.hpp>

namespace nek
{
    template <class, class = void>
    struct has_iterator
        : public false_type
    {
    };

    template <class T>
    struct has_iterator<T, void_t<typename T::iterator>>
        : public true_type
    {
    };
}

#endif

redpajama_set_name: RedPajamaGithub


text:
const CLI = require('assets-builder/node_scripts/cli');
const Dist = require('./node_scripts/Dist');
const Examples = require('./node_scripts/Examples');

CLI.init();

CLI.registerCmd('dist', 'Build dists', [], Dist);
CLI.registerCmd('examples', 'Build examples', [], Examples);

CLI.run();


text:
<?php
class Kwf_Util_Component
{
    public static function getHtmlLocations($components)
    {
        $ids = array();
        $msg = '';
        foreach ($components as $c) {
            if ($c->getPage()) {
                if (in_array($c->getPage()->componentId, $ids)) continue;
                $ids[] = $c->getPage()->componentId;
                $url = $c->getPage()->url;
                $msg .= "
".$c->getTitle()."";
            } else {
                if (in_array($c->componentId, $ids)) continue;
                $ids[] = $c->componentId;
                $t = array();
                do {
                    if (is_instance_of($c->componentClass, 'Kwc_Root_Abstract')) continue;
                    if (is_instance_of($c->componentClass, 'Kwc_Root_Category_Component')) continue;
                    if (is_instance_of($c->componentClass, 'Kwc_Root_DomainRoot_Domain_Component')) continue;
                    $n = Kwf_Trl::getInstance()->trlStaticExecute(Kwc_Abstract::getSetting($c->componentClass, 'componentName'));
                    if ($n) {
                        $t[] = str_replace('.', ' ', $n);
                    }
                } while($c = $c->parent);
                if ($t) {
                    $msg .= "
".implode(' - ', array_reverse($t));
                } else {
                    $msg .= "
".trlKwf("on multiple pages, eg. in a footer");
                }
            }
        }
        return $msg;
    }

    public static function getDuplicateProgressSteps(Kwf_Component_Data $source)
    {
        return $source->generator->getDuplicateProgressSteps($source);
    }

    /**
     * Recursively duplicate components
     *
     * You need to call afterDuplicate afterwards!
     */
    public static function duplicate(Kwf_Component_Data $source, Kwf_Component_Data $parentTarget, Zend_ProgressBar $progressBar = null)
    {
        $new = $source->generator->duplicateChild($source, $parentTarget, $progressBar);

        if (!$new) {
            throw new Kwf_Exception("Failed duplicating '$source->componentId'");
        }

        Kwf_Component_Generator_Abstract::clearInstances();
        Kwf_Component_Data_Root::reset();

        //TODO: schöner wär ein flag bei den komponenten ob es diese fkt im admin
        //gibt und dann für alle admins aufrufen
        //ändern sobald es für mehrere benötigt wird
        Kwc_Root_TrlRoot_Chained_Admin::duplicated($source, $new);

        return $new;
    }

    /**
     * Needs to be called after (multiple) duplicate() calls with a common root
     */
    public static function afterDuplicate(Kwf_Component_Data $rootSource, Kwf_Component_Data $rootTarget)
    {
        foreach (Kwf_Component_Abstract::getComponentClasses() as $c) {
            $admin = Kwf_Component_Abstract_Admin::getInstance($c);
            $admin->afterDuplicate($rootSource, $rootTarget);
        }
    }

    public static function dispatchRender()
    {
        if ((!isset($_REQUEST['url']) || !$_REQUEST["url"]) && (!isset($_REQUEST['componentId']) || !$_REQUEST['componentId']) && (!isset($_REQUEST['dbId']) || !$_REQUEST['dbId'])) {
            throw new Kwf_Exception_NotFound();
        }
        if (isset($_REQUEST['pageUrl'])) {
            foreach (Kwf_Component_Data_Root::getInstance()->getPlugins('Kwf_Component_PluginRoot_Interface_PreDispatch') as $plugin) {
                $plugin->preDispatch($_REQUEST['pageUrl']);
            }
        }
        if (isset($_REQUEST['componentId'])) {
            $data = Kwf_Component_Data_Root::getInstance()->getComponentById($_REQUEST['componentId']);
        } else if (isset($_REQUEST['dbId'])) {
            $data = Kwf_Component_Data_Root::getInstance()->getComponentByDbId($_REQUEST['dbId'], array('limit'=>1));
        } else {
            $url = $_REQUEST['url'];
            if (!is_string($url)) {
                throw new Kwf_Exception_NotFound();
            }
            $parsedUrl = parse_url($url);
            if (isset($parsedUrl['query'])) {
                foreach (explode('&' , $parsedUrl['query']) as $get) {
                    if (!$get) continue;
                    $pos = strpos($get, '=');
                    $_GET[substr($get, 0, $pos)] = substr($get, $pos+1); //ouch
                    $_REQUEST[substr($get, 0, $pos)] = substr($get, $pos+1); //ouch
                }
            }
            foreach (Kwf_Component_Data_Root::getInstance()->getPlugins('Kwf_Component_PluginRoot_Interface_PreDispatch') as $p) {
                $p->preDispatch($url);
            }
            $data = Kwf_Component_Data_Root::getInstance()->getPageByUrl($url, null);
        }
        if (!$data) throw new Kwf_Exception_NotFound();
        $contentSender = Kwc_Abstract::getSetting($data->componentClass, 'contentSender');
        $contentSender = new $contentSender($data);
        $content = $contentSender->getContent(false);
        $content['contents'] = $content['content'];
        unset($content['content']);
        if (!isset($content['lifetime'])) $content['lifetime'] = false;

        $title = null;
        $titleComponent = $data->getChildComponent('-title');
        if ($titleComponent && is_instance_of($titleComponent->componentClass, 'Kwc_Box_Title_Component')) {
            $title = $titleComponent->getComponent()->getTitle();
        }

        if (isset($_REQUEST['type']) && $_REQUEST['type'] == 'json') {
            $content['contents'] = json_encode(array(
                'mimeType' => $content['mimeType'],
                'content' => $content['contents'],
                'assets' => $content['assets'],
                'title' => $title
            ));
            $content['mimeType'] = 'application/json';
        }

        Kwf_Media_Output::output($content);

        Kwf_Benchmark::shutDown();
        exit;
    }
}


text:
using gax = Google.Api.Gax;
using gaxgrpc = Google.Api.Gax.Grpc;
using gagr = Google.Api.Gax.ResourceNames;
using gciv = Google.Cloud.Iam.V1;
using proto = Google.Protobuf;
using wkt = Google.Protobuf.WellKnownTypes;
using grpccore = Grpc.Core;
using moq = Moq;
using st = System.Threading;
using stt = System.Threading.Tasks;
using xunit = Xunit;

namespace Google.Cloud.DataCatalog.V1.Tests
{
    /// <summary>Generated unit tests.</summary>
    public sealed class GeneratedPolicyTagManagerClientTest
    {
        [xunit::FactAttribute]
        public void CreateTaxonomyRequestObject()
        {
            moq::Mock<PolicyTagManager.PolicyTagManagerClient> mockGrpcClient = new moq::Mock<PolicyTagManager.PolicyTagManagerClient>(moq::MockBehavior.Strict);
            CreateTaxonomyRequest request = new CreateTaxonomyRequest
            {
                ParentAsLocationName = gagr::LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
                Taxonomy = new Taxonomy(),
            };
            Taxonomy expectedResponse = new Taxonomy
            {
                TaxonomyName = TaxonomyName.FromProjectLocationTaxonomy("[PROJECT]", "[LOCATION]", "[TAXONOMY]"),
                DisplayName = "display_name137f65c2",
                Description = "description2cf9da67",
                PolicyTagCount = -1730676159,
                TaxonomyTimestamps = new SystemTimestamps(),
                ActivatedPolicyTypes =
                {
                    Taxonomy.Types.PolicyType.Unspecified,
                },
            };
            mockGrpcClient.Setup(x => x.CreateTaxonomy(request, moq::It.IsAny<grpccore::CallOptions>())).Returns(expectedResponse);
            PolicyTagManagerClient client = new PolicyTagManagerClientImpl(mockGrpcClient.Object, null, null);
            Taxonomy response = client.CreateTaxonomy(request);
            xunit::Assert.Same(expectedResponse, response);
            mockGrpcClient.VerifyAll();
        }

        [xunit::FactAttribute]
        public async stt::Task CreateTaxonomyRequestObjectAsync()
        {
            moq::Mock<PolicyTagManager.PolicyTagManagerClient> mockGrpcClient = new moq::Mock<PolicyTagManager.PolicyTagManagerClient>(moq::MockBehavior.Strict);
            CreateTaxonomyRequest request = new CreateTaxonomyRequest
            {
                ParentAsLocationName = gagr::LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
                Taxonomy = new Taxonomy(),
            };
            Taxonomy expectedResponse = new Taxonomy
            {
                TaxonomyName = TaxonomyName.FromProjectLocationTaxonomy("[PROJECT]", "[LOCATION]", "[TAXONOMY]"),
                DisplayName = "display_name137f65c2",
                Description = "description2cf9da67",
                PolicyTagCount = -1730676159,
                TaxonomyTimestamps = new SystemTimestamps(),
                ActivatedPolicyTypes =
                {
                    Taxonomy.Types.PolicyType.Unspecified,
                },
            };
            mockGrpcClient.Setup(x => x.CreateTaxonomyAsync(request, moq::It.IsAny<grpccore::CallOptions>())).Returns(new grpccore::AsyncUnaryCall<Taxonomy>(stt::Task.FromResult(expectedResponse), null, null, null, null));
            PolicyTagManagerClient client = new PolicyTagManagerClientImpl(mockGrpcClient.Object, null, null);
            Taxonomy responseCallSettings = await client.CreateTaxonomyAsync(request, gaxgrpc::CallSettings.FromCancellationToken(st::CancellationToken.None));
            xunit::Assert.Same(expectedResponse, responseCallSettings);
            Taxonomy responseCancellationToken = await client.CreateTaxonomyAsync(request, st::CancellationToken.None);
            xunit::Assert.Same(expectedResponse, responseCancellationToken);
            mockGrpcClient.VerifyAll();
        }

        [xunit::FactAttribute]
        public void CreateTaxonomy()
        {
            moq::Mock<PolicyTagManager.PolicyTagManagerClient> mockGrpcClient = new moq::Mock<PolicyTagManager.PolicyTagManagerClient>(moq::MockBehavior.Strict);
            CreateTaxonomyRequest request = new CreateTaxonomyRequest
            {
                ParentAsLocationName = gagr::LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
                Taxonomy = new Taxonomy(),
            };
            Taxonomy expectedResponse = new Taxonomy
            {
                TaxonomyName = TaxonomyName.FromProjectLocationTaxonomy("[PROJECT]", "[LOCATION]", "[TAXONOMY]"),
                DisplayName = "display_name137f65c2",
                Description = "description2cf9da67",
                PolicyTagCount = -1730676159,
                TaxonomyTimestamps = new SystemTimestamps(),
                ActivatedPolicyTypes =
                {
                    Taxonomy.Types.PolicyType.Unspecified,
                },
            };
            mockGrpcClient.Setup(x => x.CreateTaxonomy(request, moq::It.IsAny<grpccore::CallOptions>())).Returns(expectedResponse);
            PolicyTagManagerClient client = new PolicyTagManagerClientImpl(mockGrpcClient.Object, null, null);
            Taxonomy response = client.CreateTaxonomy(request.Parent, request.Taxonomy);
            xunit::Assert.Same(expectedResponse, response);
            mockGrpcClient.VerifyAll();
        }

        [xunit::FactAttribute]
        public async stt::Task CreateTaxonomyAsync()
        {
            moq::Mock<PolicyTagManager.PolicyTagManagerClient> mockGrpcClient = new moq::Mock<PolicyTagManager.PolicyTagManagerClient>(moq::MockBehavior.Strict);
            CreateTaxonomyRequest request = new CreateTaxonomyRequest
            {
                ParentAsLocationName = gagr::LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
                Taxonomy = new Taxonomy(),
            };
            Taxonomy expectedResponse = new Taxonomy
            {
                TaxonomyName = TaxonomyName.FromProjectLocationTaxonomy("[PROJECT]", "[LOCATION]", "[TAXONOMY]"),
                DisplayName = "display_name137f65c2",
                Description = "description2cf9da67",
                PolicyTagCount = -1730676159,
                TaxonomyTimestamps = new SystemTimestamps(),
                ActivatedPolicyTypes =
                {
                    Taxonomy.Types.PolicyType.Unspecified,
                },
            };
            mockGrpcClient.Setup(x => x.CreateTaxonomyAsync(request, moq::It.IsAny<grpccore::CallOptions>())).Returns(new grpccore::AsyncUnaryCall<Taxonomy>(stt::Task.FromResult(expectedResponse), null, null, null, null));
            PolicyTagManagerClient client = new PolicyTagManagerClientImpl(mockGrpcClient.Object, null, null);
            Taxonomy responseCallSettings = await client.CreateTaxonomyAsync(request.Parent, request.Taxonomy, gaxgrpc::CallSettings.FromCancellationToken(st::CancellationToken.None));
            xunit::Assert.Same(expectedResponse, responseCallSettings);
            Taxonomy responseCancellationToken = await client.CreateTaxonomyAsync(request.Parent, request.Taxonomy, st::CancellationToken.None);
            xunit::Assert.Same(expectedResponse, responseCancellationToken);
            mockGrpcClient.VerifyAll();
        }

        [xunit::FactAttribute]
        public void CreateTaxonomyResourceNames()
        {
            moq::Mock<PolicyTagManager.PolicyTagManagerClient> mockGrpcClient = new moq::Mock<PolicyTagManager.PolicyTagManagerClient>(moq::MockBehavior.Strict);
            CreateTaxonomyRequest request = new CreateTaxonomyRequest
            {
                ParentAsLocationName = gagr::LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
                Taxonomy = new Taxonomy(),
            };
            Taxonomy expectedResponse = new Taxonomy
            {
                TaxonomyName = TaxonomyName.FromProjectLocationTaxonomy("[PROJECT]", "[LOCATION]", "[TAXONOMY]"),
                DisplayName = "display_name137f65c2",
                Description = "description2cf9da67",
                PolicyTagCount = -1730676159,
                TaxonomyTimestamps = new SystemTimestamps(),
                ActivatedPolicyTypes =
                {
                    Taxonomy.Types.PolicyType.Unspecified,
                },
            };
            mockGrpcClient.Setup(x => x.CreateTaxonomy(request, moq::It.IsAny<grpccore::CallOptions>())).Returns(expectedResponse);
            PolicyTagManagerClient client = new PolicyTagManagerClientImpl(mockGrpcClient.Object, null, null);
            Taxonomy response = client.CreateTaxonomy(request.ParentAsLocationName, request.Taxonomy);
            xunit::Assert.Same(expectedResponse, response);
            mockGrpcClient.VerifyAll();
        }

        [xunit::FactAttribute]
        public async stt::Task CreateTaxonomyResourceNamesAsync()
        {
            moq::Mock<PolicyTagManager.PolicyTagManagerClient> mockGrpcClient = new moq::Mock<PolicyTagManager.PolicyTagManagerClient>(moq::MockBehavior.Strict);
            CreateTaxonomyRequest request = new CreateTaxonomyRequest
            {
                ParentAsLocationName = gagr::LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
                Taxonomy = new Taxonomy(),
            };
            Taxonomy expectedResponse = new Taxonomy
            {
                TaxonomyName = TaxonomyName.FromProjectLocationTaxonomy("[PROJECT]", "[LOCATION]", "[TAXONOMY]"),
                DisplayName = "display_name137f65c2",
                Description = "description2cf9da67",
                PolicyTagCount = -1730676159,
                TaxonomyTimestamps = new SystemTimestamps(),
                ActivatedPolicyTypes =
                {
                    Taxonomy.Types.PolicyType.Unspecified,
                },
            };
            mockGrpcClient.Setup(x => x.CreateTaxonomyAsync(request, moq::It.IsAny<grpccore::CallOptions>())).Returns(new grpccore::AsyncUnaryCall<Taxonomy>(stt::Task.FromResult(expectedResponse), null, null, null, null));
            PolicyTagManagerClient client = new PolicyTagManagerClientImpl(mockGrpcClient.Object, null, null);
            Taxonomy responseCallSettings = await client.CreateTaxonomyAsync(request.ParentAsLocationName, request.Taxonomy, gaxgrpc::CallSettings.FromCancellationToken(st::CancellationToken.None));
            xunit::Assert.Same(expectedResponse, responseCallSettings);
            Taxonomy responseCancellationToken = await client.CreateTaxonomyAsync(request.ParentAsLocationName, request.Taxonomy, st::CancellationToken.None);
            xunit::Assert.Same(expectedResponse, responseCancellationToken);
            mockGrpcClient.VerifyAll();
        }

        [xunit::FactAttribute]
        public void DeleteTaxonomyRequestObject()
        {
            moq::Mock<PolicyTagManager.PolicyTagManagerClient> mockGrpcClient = new moq::Mock<PolicyTagManager.PolicyTagManagerClient>(moq::MockBehavior.Strict);
            DeleteTaxonomyRequest request = new DeleteTaxonomyRequest
            {
                TaxonomyName = TaxonomyName.FromProjectLocationTaxonomy("[PROJECT]", "[LOCATION]", "[TAXONOMY]"),
            };
            wkt::Empty expectedResponse = new wkt::Empty { };
            mockGrpcClient.Setup(x => x.DeleteTaxonomy(request, moq::It.IsAny<grpccore::CallOptions>())).Returns(expectedResponse);
            PolicyTagManagerClient client = new PolicyTagManagerClientImpl(mockGrpcClient.Object, null, null);
            client.DeleteTaxonomy(request);
            mockGrpcClient.VerifyAll();
        }

        [xunit::FactAttribute]
        public async stt::Task DeleteTaxonomyRequestObjectAsync()
        {
            moq::Mock<PolicyTagManager.PolicyTagManagerClient> mockGrpcClient = new moq::Mock<PolicyTagManager.PolicyTagManagerClient>(moq::MockBehavior.Strict);
            DeleteTaxonomyRequest request = new DeleteTaxonomyRequest
            {
                TaxonomyName = TaxonomyName.FromProjectLocationTaxonomy("[PROJECT]", "[LOCATION]", "[TAXONOMY]"),
            };
            wkt::Empty expectedResponse = new wkt::Empty { };
            mockGrpcClient.Setup(x => x.DeleteTaxonomyAsync(request, moq::It.IsAny<grpccore::CallOptions>())).Returns(new grpccore::AsyncUnaryCall<wkt::Empty>(stt::Task.FromResult(expectedResponse), null, null, null, null));
            PolicyTagManagerClient client = new PolicyTagManagerClientImpl(mockGrpcClient.Object, null, null);
            await client.DeleteTaxonomyAsync(request, gaxgrpc::CallSettings.FromCancellationToken(st::CancellationToken.None));
            await client.DeleteTaxonomyAsync(request, st::CancellationToken.None);
            mockGrpcClient.VerifyAll();
        }

        [xunit::FactAttribute]
        public void DeleteTaxonomy()
        {
            moq::Mock<PolicyTagManager.PolicyTagManagerClient> mockGrpcClient = new moq::Mock<PolicyTagManager.PolicyTagManagerClient>(moq::MockBehavior.Strict);
            DeleteTaxonomyRequest request = new DeleteTaxonomyRequest
            {
                TaxonomyName = TaxonomyName.FromProjectLocationTaxonomy("[PROJECT]", "[LOCATION]", "[TAXONOMY]"),
            };
            wkt::Empty expectedResponse = new wkt::Empty { };
            mockGrpcClient.Setup(x => x.DeleteTaxonomy(request, moq::It.IsAny<grpccore::CallOptions>())).Returns(expectedResponse);
            PolicyTagManagerClient client = new PolicyTagManagerClientImpl(mockGrpcClient.Object, null, null);
            client.DeleteTaxonomy(request.Name);
            mockGrpcClient.VerifyAll();
        }

        [xunit::FactAttribute]
        public async stt::Task DeleteTaxonomyAsync()
        {
            moq::Mock<PolicyTagManager.PolicyTagManagerClient> mockGrpcClient = new moq::Mock<PolicyTagManager.PolicyTagManagerClient>(moq::MockBehavior.Strict);
            DeleteTaxonomyRequest request = new DeleteTaxonomyRequest
            {
                TaxonomyName = TaxonomyName.FromProjectLocationTaxonomy("[PROJECT]", "[LOCATION]", "[TAXONOMY]"),
            };
            wkt::Empty expectedResponse = new wkt::Empty { };
            mockGrpcClient.Setup(x => x.DeleteTaxonomyAsync(request, moq::It.IsAny<grpccore::CallOptions>())).Returns(new grpccore::AsyncUnaryCall<wkt::Empty>(stt::Task.FromResult(expectedResponse), null, null, null, null));
            PolicyTagManagerClient client = new PolicyTagManagerClientImpl(mockGrpcClient.Object, null, null);
            await client.DeleteTaxonomyAsync(request.Name, gaxgrpc::CallSettings.FromCancellationToken(st::CancellationToken.None));
            await client.DeleteTaxonomyAsync(request.Name, st::CancellationToken.None);
            mockGrpcClient.VerifyAll();
        }

        [xunit::FactAttribute]
        public void DeleteTaxonomyResourceNames()
        {
            moq::Mock<PolicyTagManager.PolicyTagManagerClient> mockGrpcClient = new moq::Mock<PolicyTagManager.PolicyTagManagerClient>(moq::MockBehavior.Strict);
            DeleteTaxonomyRequest request = new DeleteTaxonomyRequest
            {
                TaxonomyName = TaxonomyName.FromProjectLocationTaxonomy("[PROJECT]", "[LOCATION]", "[TAXONOMY]"),
            };
            wkt::Empty expectedResponse = new wkt::Empty { };
            mockGrpcClient.Setup(x => x.DeleteTaxonomy(request, moq::It.IsAny<grpccore::CallOptions>())).Returns(expectedResponse);
            PolicyTagManagerClient client = new PolicyTagManagerClientImpl(mockGrpcClient.Object, null, null);
            client.DeleteTaxonomy(request.TaxonomyName);
            mockGrpcClient.VerifyAll();
        }

        [xunit::FactAttribute]
        public async stt::Task DeleteTaxonomyResourceNamesAsync()
        {
            moq::Mock<PolicyTagManager.PolicyTagManagerClient> mockGrpcClient = new moq::Mock<PolicyTagManager.PolicyTagManagerClient>(moq::MockBehavior.Strict);
            DeleteTaxonomyRequest request = new DeleteTaxonomyRequest
            {
                TaxonomyName = TaxonomyName.FromProjectLocationTaxonomy("[PROJECT]", "[LOCATION]", "[TAXONOMY]"),
            };
            wkt::Empty expectedResponse = new wkt::Empty { };
            mockGrpcClient.Setup(x => x.DeleteTaxonomyAsync(request, moq::It.IsAny<grpccore::CallOptions>())).Returns(new grpccore::AsyncUnaryCall<wkt::Empty>(stt::Task.FromResult(expectedResponse), null, null, null, null));
            PolicyTagManagerClient client = new PolicyTagManagerClientImpl(mockGrpcClient.Object, null, null);
            await client.DeleteTaxonomyAsync(request.TaxonomyName, gaxgrpc::CallSettings.FromCancellationToken(st::CancellationToken.None));
            await client.DeleteTaxonomyAsync(request.TaxonomyName, st::CancellationToken.None);
            mockGrpcClient.VerifyAll();
        }

        [xunit::FactAttribute]
        public void UpdateTaxonomyRequestObject()
        {
            moq::Mock<PolicyTagManager.PolicyTagManagerClient> mockGrpcClient = new moq::Mock<PolicyTagManager.PolicyTagManagerClient>(moq::MockBehavior.Strict);
            UpdateTaxonomyRequest request = new UpdateTaxonomyRequest
            {
                Taxonomy = new Taxonomy(),
                UpdateMask = new wkt::FieldMask(),
            };
            Taxonomy expectedResponse = new Taxonomy
            {
                TaxonomyName = TaxonomyName.FromProjectLocationTaxonomy("[PROJECT]", "[LOCATION]", "[TAXONOMY]"),
                DisplayName = "display_name137f65c2",
                Description = "description2cf9da67",
                PolicyTagCount = -1730676159,
                TaxonomyTimestamps = new SystemTimestamps(),
                ActivatedPolicyTypes =
                {
                    Taxonomy.Types.PolicyType.Unspecified,
                },
            };
            mockGrpcClient.Setup(x => x.UpdateTaxonomy(request, moq::It.IsAny<grpccore::CallOptions>())).Returns(expectedResponse);
            PolicyTagManagerClient client = new PolicyTagManagerClientImpl(mockGrpcClient.Object, null, null);
            Taxonomy response = client.UpdateTaxonomy(request);
            xunit::Assert.Same(expectedResponse, response);
            mockGrpcClient.VerifyAll();
        }

        [xunit::FactAttribute]
        public async stt::Task UpdateTaxonomyRequestObjectAsync()
        {
            moq::Mock<PolicyTagManager.PolicyTagManagerClient> mockGrpcClient = new moq::Mock<PolicyTagManager.PolicyTagManagerClient>(moq::MockBehavior.Strict);
            UpdateTaxonomyRequest request = new UpdateTaxonomyRequest
            {
                Taxonomy = new Taxonomy(),
                UpdateMask = new wkt::FieldMask(),
            };
            Taxonomy expectedResponse = new Taxonomy
            {
                TaxonomyName = TaxonomyName.FromProjectLocationTaxonomy("[PROJECT]", "[LOCATION]", "[TAXONOMY]"),
                DisplayName = "display_name137f65c2",
                Description = "description2cf9da67",
                PolicyTagCount = -1730676159,
                TaxonomyTimestamps = new SystemTimestamps(),
                ActivatedPolicyTypes =
                {
                    Taxonomy.Types.PolicyType.Unspecified,
                },
            };
            mockGrpcClient.Setup(x => x.UpdateTaxonomyAsync(request, moq::It.IsAny<grpccore::CallOptions>())).Returns(new grpccore::AsyncUnaryCall<Taxonomy>(stt::Task.FromResult(expectedResponse), null, null, null, null));
            PolicyTagManagerClient client = new PolicyTagManagerClientImpl(mockGrpcClient.Object, null, null);
            Taxonomy responseCallSettings = await client.UpdateTaxonomyAsync(request, gaxgrpc::CallSettings.FromCancellationToken(st::CancellationToken.None));
            xunit::Assert.Same(expectedResponse, responseCallSettings);
            Taxonomy responseCancellationToken = await client.UpdateTaxonomyAsync(request, st::CancellationToken.None);
            xunit::Assert.Same(expectedResponse, responseCancellationToken);
            mockGrpcClient.VerifyAll();
        }

        [xunit::FactAttribute]
        public void UpdateTaxonomy()
        {
            moq::Mock<PolicyTagManager.PolicyTagManagerClient> mockGrpcClient = new moq::Mock<PolicyTagManager.PolicyTagManagerClient>(moq::MockBehavior.Strict);
            UpdateTaxonomyRequest request = new UpdateTaxonomyRequest
            {
                Taxonomy = new Taxonomy(),
            };
            Taxonomy expectedResponse = new Taxonomy
            {
                TaxonomyName = TaxonomyName.FromProjectLocationTaxonomy("[PROJECT]", "[LOCATION]", "[TAXONOMY]"),
                DisplayName = "display_name137f65c2",
                Description = "description2cf9da67",
                PolicyTagCount = -1730676159,
                TaxonomyTimestamps = new SystemTimestamps(),
                ActivatedPolicyTypes =
                {
                    Taxonomy.Types.PolicyType.Unspecified,
                },
            };
            mockGrpcClient.Setup(x => x.UpdateTaxonomy(request, moq::It.IsAny<grpccore::CallOptions>())).Returns(expectedResponse);
            PolicyTagManagerClient client = new PolicyTagManagerClientImpl(mockGrpcClient.Object, null, null);
            Taxonomy response = client.UpdateTaxonomy(request.Taxonomy);
            xunit::Assert.Same(expectedResponse, response);
            mockGrpcClient.VerifyAll();
        }

        [xunit::FactAttribute]
        public async stt::Task UpdateTaxonomyAsync()
        {
            moq::Mock<PolicyTagManager.PolicyTagManagerClient> mockGrpcClient = new moq::Mock<PolicyTagManager.PolicyTagManagerClient>(moq::MockBehavior.Strict);
            UpdateTaxonomyRequest request = new UpdateTaxonomyRequest
            {
                Taxonomy = new Taxonomy(),
            };
            Taxonomy expectedResponse = new Taxonomy
            {
                TaxonomyName = TaxonomyName.FromProjectLocationTaxonomy("[PROJECT]", "[LOCATION]", "[TAXONOMY]"),
                DisplayName = "display_name137f65c2",
                Description = "description2cf9da67",
                PolicyTagCount = -1730676159,
                TaxonomyTimestamps = new SystemTimestamps(),
                ActivatedPolicyTypes =
                {
                    Taxonomy.Types.PolicyType.Unspecified,
                },
            };
            mockGrpcClient.Setup(x => x.UpdateTaxonomyAsync(request, moq::It.IsAny<grpccore::CallOptions>())).Returns(new grpccore::AsyncUnaryCall<Taxonomy>(stt::Task.FromResult(expectedResponse), null, null, null, null));
            PolicyTagManagerClient client = new PolicyTagManagerClientImpl(mockGrpcClient.Object, null, null);
            Taxonomy responseCallSettings = await client.UpdateTaxonomyAsync(request.Taxonomy, gaxgrpc::CallSettings.FromCancellationToken(st::CancellationToken.None));
            xunit::Assert.Same(expectedResponse, responseCallSettings);
            Taxonomy responseCancellationToken = await client.UpdateTaxonomyAsync(request.Taxonomy, st::CancellationToken.None);
            xunit::Assert.Same(expectedResponse, responseCancellationToken);
            mockGrpcClient.VerifyAll();
        }

        [xunit::FactAttribute]
        public void GetTaxonomyRequestObject()
        {
            moq::Mock<PolicyTagManager.PolicyTagManagerClient> mockGrpcClient = new moq::Mock<PolicyTagManager.PolicyTagManagerClient>(moq::MockBehavior.Strict);
            GetTaxonomyRequest request = new GetTaxonomyRequest
            {
                TaxonomyName = TaxonomyName.FromProjectLocationTaxonomy("[PROJECT]", "[LOCATION]", "[TAXONOMY]"),
            };
            Taxonomy expectedResponse = new Taxonomy
            {
                TaxonomyName = TaxonomyName.FromProjectLocationTaxonomy("[PROJECT]", "[LOCATION]", "[TAXONOMY]"),
                DisplayName = "display_name137f65c2",
                Description = "description2cf9da67",
                PolicyTagCount = -1730676159,
                TaxonomyTimestamps = new SystemTimestamps(),
                ActivatedPolicyTypes =
                {
                    Taxonomy.Types.PolicyType.Unspecified,
                },
            };
            mockGrpcClient.Setup(x => x.GetTaxonomy(request, moq::It.IsAny<grpccore::CallOptions>())).Returns(expectedResponse);
            PolicyTagManagerClient client = new PolicyTagManagerClientImpl(mockGrpcClient.Object, null, null);
            Taxonomy response = client.GetTaxonomy(request);
            xunit::Assert.Same(expectedResponse, response);
            mockGrpcClient.VerifyAll();
        }

        [xunit::FactAttribute]
        public async stt::Task GetTaxonomyRequestObjectAsync()
        {
            moq::Mock<PolicyTagManager.PolicyTagManagerClient> mockGrpcClient = new moq::Mock<PolicyTagManager.PolicyTagManagerClient>(moq::MockBehavior.Strict);
            GetTaxonomyRequest request = new GetTaxonomyRequest
            {
                TaxonomyName = TaxonomyName.FromProjectLocationTaxonomy("[PROJECT]", "[LOCATION]", "[TAXONOMY]"),
            };
            Taxonomy expectedResponse = new Taxonomy
            {
                TaxonomyName = TaxonomyName.FromProjectLocationTaxonomy("[PROJECT]", "[LOCATION]", "[TAXONOMY]"),
                DisplayName = "display_name137f65c2",
                Description = "description2cf9da67",
                PolicyTagCount = -1730676159,
                TaxonomyTimestamps = new SystemTimestamps(),
                ActivatedPolicyTypes =
                {
                    Taxonomy.Types.PolicyType.Unspecified,
                },
            };
            mockGrpcClient.Setup(x => x.GetTaxonomyAsync(request, moq::It.IsAny<grpccore::CallOptions>())).Returns(new grpccore::AsyncUnaryCall<Taxonomy>(stt::Task.FromResult(expectedResponse), null, null, null, null));
            PolicyTagManagerClient client = new PolicyTagManagerClientImpl(mockGrpcClient.Object, null, null);
            Taxonomy responseCallSettings = await client.GetTaxonomyAsync(request, gaxgrpc::CallSettings.FromCancellationToken(st::CancellationToken.None));
            xunit::Assert.Same(expectedResponse, responseCallSettings);
            Taxonomy responseCancellationToken = await client.GetTaxonomyAsync(request, st::CancellationToken.None);
            xunit::Assert.Same(expectedResponse, responseCancellationToken);
            mockGrpcClient.VerifyAll();
        }

        [xunit::FactAttribute]
        public void GetTaxonomy()
        {
            moq::Mock<PolicyTagManager.PolicyTagManagerClient> mockGrpcClient = new moq::Mock<PolicyTagManager.PolicyTagManagerClient>(moq::MockBehavior.Strict);
            GetTaxonomyRequest request = new GetTaxonomyRequest
            {
                TaxonomyName = TaxonomyName.FromProjectLocationTaxonomy("[PROJECT]", "[LOCATION]", "[TAXONOMY]"),
            };
            Taxonomy expectedResponse = new Taxonomy
            {
                TaxonomyName = TaxonomyName.FromProjectLocationTaxonomy("[PROJECT]", "[LOCATION]", "[TAXONOMY]"),
                DisplayName = "display_name137f65c2",
                Description = "description2cf9da67",
                PolicyTagCount = -1730676159,
                TaxonomyTimestamps = new SystemTimestamps(),
                ActivatedPolicyTypes =
                {
                    Taxonomy.Types.PolicyType.Unspecified,
                },
            };
            mockGrpcClient.Setup(x => x.GetTaxonomy(request, moq::It.IsAny<grpccore::CallOptions>())).Returns(expectedResponse);
            PolicyTagManagerClient client = new PolicyTagManagerClientImpl(mockGrpcClient.Object, null, null);
            Taxonomy response = client.GetTaxonomy(request.Name);
            xunit::Assert.Same(expectedResponse, response);
            mockGrpcClient.VerifyAll();
        }

        [xunit::FactAttribute]
        public async stt::Task GetTaxonomyAsync()
        {
            moq::Mock<PolicyTagManager.PolicyTagManagerClient> mockGrpcClient = new moq::Mock<PolicyTagManager.PolicyTagManagerClient>(moq::MockBehavior.Strict);
            GetTaxonomyRequest request = new GetTaxonomyRequest
            {
                TaxonomyName = TaxonomyName.FromProjectLocationTaxonomy("[PROJECT]", "[LOCATION]", "[TAXONOMY]"),
            };
            Taxonomy expectedResponse = new Taxonomy
            {
                TaxonomyName = TaxonomyName.FromProjectLocationTaxonomy("[PROJECT]", "[LOCATION]", "[TAXONOMY]"),
                DisplayName = "display_name137f65c2",
                Description = "description2cf9da67",
                PolicyTagCount = -1730676159,
                TaxonomyTimestamps = new SystemTimestamps(),
                ActivatedPolicyTypes =
                {
                    Taxonomy.Types.PolicyType.Unspecified,
                },
            };
            mockGrpcClient.Setup(x => x.GetTaxonomyAsync(request, moq::It.IsAny<grpccore::CallOptions>())).Returns(new grpccore::AsyncUnaryCall<Taxonomy>(stt::Task.FromResult(expectedResponse), null, null, null, null));
            PolicyTagManagerClient client = new PolicyTagManagerClientImpl(mockGrpcClient.Object, null, null);
            Taxonomy responseCallSettings = await client.GetTaxonomyAsync(request.Name, gaxgrpc::CallSettings.FromCancellationToken(st::CancellationToken.None));
            xunit::Assert.Same(expectedResponse, responseCallSettings);
            Taxonomy responseCancellationToken = await client.GetTaxonomyAsync(request.Name, st::CancellationToken.None);
            xunit::Assert.Same(expectedResponse, responseCancellationToken);
            mockGrpcClient.VerifyAll();
        }

        [xunit::FactAttribute]
        public void GetTaxonomyResourceNames()
        {
            moq::Mock<PolicyTagManager.PolicyTagManagerClient> mockGrpcClient = new moq::Mock<PolicyTagManager.PolicyTagManagerClient>(moq::MockBehavior.Strict);
            GetTaxonomyRequest request = new GetTaxonomyRequest
            {
                TaxonomyName = TaxonomyName.FromProjectLocationTaxonomy("[PROJECT]", "[LOCATION]", "[TAXONOMY]"),
            };
            Taxonomy expectedResponse = new Taxonomy
            {
                TaxonomyName = TaxonomyName.FromProjectLocationTaxonomy("[PROJECT]", "[LOCATION]", "[TAXONOMY]"),
                DisplayName = "display_name137f65c2",
                Description = "description2cf9da67",
                PolicyTagCount = -1730676159,
                TaxonomyTimestamps = new SystemTimestamps(),
                ActivatedPolicyTypes =
                {
                    Taxonomy.Types.PolicyType.Unspecified,
                },
            };
            mockGrpcClient.Setup(x => x.GetTaxonomy(request, moq::It.IsAny<grpccore::CallOptions>())).Returns(expectedResponse);
            PolicyTagManagerClient client = new PolicyTagManagerClientImpl(mockGrpcClient.Object, null, null);
            Taxonomy response = client.GetTaxonomy(request.TaxonomyName);
            xunit::Assert.Same(expectedResponse, response);
            mockGrpcClient.VerifyAll();
        }

        [xunit::FactAttribute]
        public async stt::Task GetTaxonomyResourceNamesAsync()
        {
            moq::Mock<PolicyTagManager.PolicyTagManagerClient> mockGrpcClient = new moq::Mock<PolicyTagManager.PolicyTagManagerClient>(moq::MockBehavior.Strict);
            GetTaxonomyRequest request = new GetTaxonomyRequest
            {
                TaxonomyName = TaxonomyName.FromProjectLocationTaxonomy("[PROJECT]", "[LOCATION]", "[TAXONOMY]"),
            };
            Taxonomy expectedResponse = new Taxonomy
            {
                TaxonomyName = TaxonomyName.FromProjectLocationTaxonomy("[PROJECT]", "[LOCATION]", "[TAXONOMY]"),
                DisplayName = "display_name137f65c2",
                Description = "description2cf9da67",
                PolicyTagCount = -1730676159,
                TaxonomyTimestamps = new SystemTimestamps(),
                ActivatedPolicyTypes =
                {
                    Taxonomy.Types.PolicyType.Unspecified,
                },
            };
            mockGrpcClient.Setup(x => x.GetTaxonomyAsync(request, moq::It.IsAny<grpccore::CallOptions>())).Returns(new grpccore::AsyncUnaryCall<Taxonomy>(stt::Task.FromResult(expectedResponse), null, null, null, null));
            PolicyTagManagerClient client = new PolicyTagManagerClientImpl(mockGrpcClient.Object, null, null);
            Taxonomy responseCallSettings = await client.GetTaxonomyAsync(request.TaxonomyName, gaxgrpc::CallSettings.FromCancellationToken(st::CancellationToken.None));
            xunit::Assert.Same(expectedResponse, responseCallSettings);
            Taxonomy responseCancellationToken = await client.GetTaxonomyAsync(request.TaxonomyName, st::CancellationToken.None);
            xunit::Assert.Same(expectedResponse, responseCancellationToken);
            mockGrpcClient.VerifyAll();
        }

        [xunit::FactAttribute]
        public void CreatePolicyTagRequestObject()
        {
            moq::Mock<PolicyTagManager.PolicyTagManagerClient> mockGrpcClient = new moq::Mock<PolicyTagManager.PolicyTagManagerClient>(moq::MockBehavior.Strict);
            CreatePolicyTagRequest request = new CreatePolicyTagRequest
            {
                ParentAsTaxonomyName = TaxonomyName.FromProjectLocationTaxonomy("[PROJECT]", "[LOCATION]", "[TAXONOMY]"),
                PolicyTag = new PolicyTag(),
            };
            PolicyTag expectedResponse = new PolicyTag
            {
                PolicyTagName = PolicyTagName.FromProjectLocationTaxonomyPolicyTag("[PROJECT]", "[LOCATION]", "[TAXONOMY]", "[POLICY_TAG]"),
                DisplayName = "display_name137f65c2",
                Description = "description2cf9da67",
                ParentPolicyTag = "parent_policy_tagbc591931",
                ChildPolicyTags =
                {
                    "child_policy_tags11be0699",
                },
            };
            mockGrpcClient.Setup(x => x.CreatePolicyTag(request, moq::It.IsAny<grpccore::CallOptions>())).Returns(expectedResponse);
            PolicyTagManagerClient client = new PolicyTagManagerClientImpl(mockGrpcClient.Object, null, null);
            PolicyTag response = client.CreatePolicyTag(request);
            xunit::Assert.Same(expectedResponse, response);
            mockGrpcClient.VerifyAll();
        }

        [xunit::FactAttribute]
        public async stt::Task CreatePolicyTagRequestObjectAsync()
        {
            moq::Mock<PolicyTagManager.PolicyTagManagerClient> mockGrpcClient = new moq::Mock<PolicyTagManager.PolicyTagManagerClient>(moq::MockBehavior.Strict);
            CreatePolicyTagRequest request = new CreatePolicyTagRequest
            {
                ParentAsTaxonomyName = TaxonomyName.FromProjectLocationTaxonomy("[PROJECT]", "[LOCATION]", "[TAXONOMY]"),
                PolicyTag = new PolicyTag(),
            };
            PolicyTag expectedResponse = new PolicyTag
            {
                PolicyTagName = PolicyTagName.FromProjectLocationTaxonomyPolicyTag("[PROJECT]", "[LOCATION]", "[TAXONOMY]", "[POLICY_TAG]"),
                DisplayName = "display_name137f65c2",
                Description = "description2cf9da67",
                ParentPolicyTag = "parent_policy_tagbc591931",
                ChildPolicyTags =
                {
                    "child_policy_tags11be0699",
                },
            };
            mockGrpcClient.Setup(x => x.CreatePolicyTagAsync(request, moq::It.IsAny<grpccore::CallOptions>())).Returns(new grpccore::AsyncUnaryCall<PolicyTag>(stt::Task.FromResult(expectedResponse), null, null, null, null));
            PolicyTagManagerClient client = new PolicyTagManagerClientImpl(mockGrpcClient.Object, null, null);
            PolicyTag responseCallSettings = await client.CreatePolicyTagAsync(request, gaxgrpc::CallSettings.FromCancellationToken(st::CancellationToken.None));
            xunit::Assert.Same(expectedResponse, responseCallSettings);
            PolicyTag responseCancellationToken = await client.CreatePolicyTagAsync(request, st::CancellationToken.None);
            xunit::Assert.Same(expectedResponse, responseCancellationToken);
            mockGrpcClient.VerifyAll();
        }

        [xunit::FactAttribute]
        public void CreatePolicyTag()
        {
            moq::Mock<PolicyTagManager.PolicyTagManagerClient> mockGrpcClient = new moq::Mock<PolicyTagManager.PolicyTagManagerClient>(moq::MockBehavior.Strict);
            CreatePolicyTagRequest request = new CreatePolicyTagRequest
            {
                ParentAsTaxonomyName = TaxonomyName.FromProjectLocationTaxonomy("[PROJECT]", "[LOCATION]", "[TAXONOMY]"),
                PolicyTag = new PolicyTag(),
            };
            PolicyTag expectedResponse = new PolicyTag
            {
                PolicyTagName = PolicyTagName.FromProjectLocationTaxonomyPolicyTag("[PROJECT]", "[LOCATION]", "[TAXONOMY]", "[POLICY_TAG]"),
                DisplayName = "display_name137f65c2",
                Description = "description2cf9da67",
                ParentPolicyTag = "parent_policy_tagbc591931",
                ChildPolicyTags =
                {
                    "child_policy_tags11be0699",
                },
            };
            mockGrpcClient.Setup(x => x.CreatePolicyTag(request, moq::It.IsAny<grpccore::CallOptions>())).Returns(expectedResponse);
            PolicyTagManagerClient client = new PolicyTagManagerClientImpl(mockGrpcClient.Object, null, null);
            PolicyTag response = client.CreatePolicyTag(request.Parent, request.PolicyTag);
            xunit::Assert.Same(expectedResponse, response);
            mockGrpcClient.VerifyAll();
        }

        [xunit::FactAttribute]
        public async stt::Task CreatePolicyTagAsync()
        {
            moq::Mock<PolicyTagManager.PolicyTagManagerClient> mockGrpcClient = new moq::Mock<PolicyTagManager.PolicyTagManagerClient>(moq::MockBehavior.Strict);
            CreatePolicyTagRequest request = new CreatePolicyTagRequest
            {
                ParentAsTaxonomyName = TaxonomyName.FromProjectLocationTaxonomy("[PROJECT]", "[LOCATION]", "[TAXONOMY]"),
                PolicyTag = new PolicyTag(),
            };
            PolicyTag expectedResponse = new PolicyTag
            {
                PolicyTagName = PolicyTagName.FromProjectLocationTaxonomyPolicyTag("[PROJECT]", "[LOCATION]", "[TAXONOMY]", "[POLICY_TAG]"),
                DisplayName = "display_name137f65c2",
                Description = "description2cf9da67",
                ParentPolicyTag = "parent_policy_tagbc591931",
                ChildPolicyTags =
                {
                    "child_policy_tags11be0699",
                },
            };
            mockGrpcClient.Setup(x => x.CreatePolicyTagAsync(request, moq::It.IsAny<grpccore::CallOptions>())).Returns(new grpccore::AsyncUnaryCall<PolicyTag>(stt::Task.FromResult(expectedResponse), null, null, null, null));
            PolicyTagManagerClient client = new PolicyTagManagerClientImpl(mockGrpcClient.Object, null, null);
            PolicyTag responseCallSettings = await client.CreatePolicyTagAsync(request.Parent, request.PolicyTag, gaxgrpc::CallSettings.FromCancellationToken(st::CancellationToken.None));
            xunit::Assert.Same(expectedResponse, responseCallSettings);
            PolicyTag responseCancellationToken = await client.CreatePolicyTagAsync(request.Parent, request.PolicyTag, st::CancellationToken.None);
            xunit::Assert.Same(expectedResponse, responseCancellationToken);
            mockGrpcClient.VerifyAll();
        }

        [xunit::FactAttribute]
        public void CreatePolicyTagResourceNames()
        {
            moq::Mock<PolicyTagManager.PolicyTagManagerClient> mockGrpcClient = new moq::Mock<PolicyTagManager.PolicyTagManagerClient>(moq::MockBehavior.Strict);
            CreatePolicyTagRequest request = new CreatePolicyTagRequest
            {
                ParentAsTaxonomyName = TaxonomyName.FromProjectLocationTaxonomy("[PROJECT]", "[LOCATION]", "[TAXONOMY]"),
                PolicyTag = new PolicyTag(),
            };
            PolicyTag expectedResponse = new PolicyTag
            {
                PolicyTagName = PolicyTagName.FromProjectLocationTaxonomyPolicyTag("[PROJECT]", "[LOCATION]", "[TAXONOMY]", "[POLICY_TAG]"),
                DisplayName = "display_name137f65c2",
                Description = "description2cf9da67",
                ParentPolicyTag = "parent_policy_tagbc591931",
                ChildPolicyTags =
                {
                    "child_policy_tags11be0699",
                },
            };
            mockGrpcClient.Setup(x => x.CreatePolicyTag(request, moq::It.IsAny<grpccore::CallOptions>())).Returns(expectedResponse);
            PolicyTagManagerClient client = new PolicyTagManagerClientImpl(mockGrpcClient.Object, null, null);
            PolicyTag response = client.CreatePolicyTag(request.ParentAsTaxonomyName, request.PolicyTag);
            xunit::Assert.Same(expectedResponse, response);
            mockGrpcClient.VerifyAll();
        }

        [xunit::FactAttribute]
        public async stt::Task CreatePolicyTagResourceNamesAsync()
        {
            moq::Mock<PolicyTagManager.PolicyTagManagerClient> mockGrpcClient = new moq::Mock<PolicyTagManager.PolicyTagManagerClient>(moq::MockBehavior.Strict);
            CreatePolicyTagRequest request = new CreatePolicyTagRequest
            {
                ParentAsTaxonomyName = TaxonomyName.FromProjectLocationTaxonomy("[PROJECT]", "[LOCATION]", "[TAXONOMY]"),
                PolicyTag = new PolicyTag(),
            };
            PolicyTag expectedResponse = new PolicyTag
            {
                PolicyTagName = PolicyTagName.FromProjectLocationTaxonomyPolicyTag("[PROJECT]", "[LOCATION]", "[TAXONOMY]", "[POLICY_TAG]"),
                DisplayName = "display_name137f65c2",
                Description = "description2cf9da67",
                ParentPolicyTag = "parent_policy_tagbc591931",
                ChildPolicyTags =
                {
                    "child_policy_tags11be0699",
                },
            };
            mockGrpcClient.Setup(x => x.CreatePolicyTagAsync(request, moq::It.IsAny<grpccore::CallOptions>())).Returns(new grpccore::AsyncUnaryCall<PolicyTag>(stt::Task.FromResult(expectedResponse), null, null, null, null));
            PolicyTagManagerClient client = new PolicyTagManagerClientImpl(mockGrpcClient.Object, null, null);
            PolicyTag responseCallSettings = await client.CreatePolicyTagAsync(request.ParentAsTaxonomyName, request.PolicyTag, gaxgrpc::CallSettings.FromCancellationToken(st::CancellationToken.None));
            xunit::Assert.Same(expectedResponse, responseCallSettings);
            PolicyTag responseCancellationToken = await client.CreatePolicyTagAsync(request.ParentAsTaxonomyName, request.PolicyTag, st::CancellationToken.None);
            xunit::Assert.Same(expectedResponse, responseCancellationToken);
            mockGrpcClient.VerifyAll();
        }

        [xunit::FactAttribute]
        public void DeletePolicyTagRequestObject()
        {
            moq::Mock<PolicyTagManager.PolicyTagManagerClient> mockGrpcClient = new moq::Mock<PolicyTagManager.PolicyTagManagerClient>(moq::MockBehavior.Strict);
            DeletePolicyTagRequest request = new DeletePolicyTagRequest
            {
                PolicyTagName = PolicyTagName.FromProjectLocationTaxonomyPolicyTag("[PROJECT]", "[LOCATION]", "[TAXONOMY]", "[POLICY_TAG]"),
            };
            wkt::Empty expectedResponse = new wkt::Empty { };
            mockGrpcClient.Setup(x => x.DeletePolicyTag(request, moq::It.IsAny<grpccore::CallOptions>())).Returns(expectedResponse);
            PolicyTagManagerClient client = new PolicyTagManagerClientImpl(mockGrpcClient.Object, null, null);
            client.DeletePolicyTag(request);
            mockGrpcClient.VerifyAll();
        }

        [xunit::FactAttribute]
        public async stt::Task DeletePolicyTagRequestObjectAsync()
        {
            moq::Mock<PolicyTagManager.PolicyTagManagerClient> mockGrpcClient = new moq::Mock<PolicyTagManager.PolicyTagManagerClient>(moq::MockBehavior.Strict);
            DeletePolicyTagRequest request = new DeletePolicyTagRequest
            {
                PolicyTagName = PolicyTagName.FromProjectLocationTaxonomyPolicyTag("[PROJECT]", "[LOCATION]", "[TAXONOMY]", "[POLICY_TAG]"),
            };
            wkt::Empty expectedResponse = new wkt::Empty { };
            mockGrpcClient.Setup(x => x.DeletePolicyTagAsync(request, moq::It.IsAny<grpccore::CallOptions>())).Returns(new grpccore::AsyncUnaryCall<wkt::Empty>(stt::Task.FromResult(expectedResponse), null, null, null, null));
            PolicyTagManagerClient client = new PolicyTagManagerClientImpl(mockGrpcClient.Object, null, null);
            await client.DeletePolicyTagAsync(request, gaxgrpc::CallSettings.FromCancellationToken(st::CancellationToken.None));
            await client.DeletePolicyTagAsync(request, st::CancellationToken.None);
            mockGrpcClient.VerifyAll();
        }

        [xunit::FactAttribute]
        public void DeletePolicyTag()
        {
            moq::Mock<PolicyTagManager.PolicyTagManagerClient> mockGrpcClient = new moq::Mock<PolicyTagManager.PolicyTagManagerClient>(moq::MockBehavior.Strict);
            DeletePolicyTagRequest request = new DeletePolicyTagRequest
            {
                PolicyTagName = PolicyTagName.FromProjectLocationTaxonomyPolicyTag("[PROJECT]", "[LOCATION]", "[TAXONOMY]", "[POLICY_TAG]"),
            };
            wkt::Empty expectedResponse = new wkt::Empty { };
            mockGrpcClient.Setup(x => x.DeletePolicyTag(request, moq::It.IsAny<grpccore::CallOptions>())).Returns(expectedResponse);
            PolicyTagManagerClient client = new PolicyTagManagerClientImpl(mockGrpcClient.Object, null, null);
            client.DeletePolicyTag(request.Name);
            mockGrpcClient.VerifyAll();
        }

        [xunit::FactAttribute]
        public async stt::Task DeletePolicyTagAsync()
        {
            moq::Mock<PolicyTagManager.PolicyTagManagerClient> mockGrpcClient = new moq::Mock<PolicyTagManager.PolicyTagManagerClient>(moq::MockBehavior.Strict);
            DeletePolicyTagRequest request = new DeletePolicyTagRequest
            {
                PolicyTagName = PolicyTagName.FromProjectLocationTaxonomyPolicyTag("[PROJECT]", "[LOCATION]", "[TAXONOMY]", "[POLICY_TAG]"),
            };
            wkt::Empty expectedResponse = new wkt::Empty { };
            mockGrpcClient.Setup(x => x.DeletePolicyTagAsync(request, moq::It.IsAny<grpccore::CallOptions>())).Returns(new grpccore::AsyncUnaryCall<wkt::Empty>(stt::Task.FromResult(expectedResponse), null, null, null, null));
            PolicyTagManagerClient client = new PolicyTagManagerClientImpl(mockGrpcClient.Object, null, null);
            await client.DeletePolicyTagAsync(request.Name, gaxgrpc::CallSettings.FromCancellationToken(st::CancellationToken.None));
            await client.DeletePolicyTagAsync(request.Name, st::CancellationToken.None);
            mockGrpcClient.VerifyAll();
        }

        [xunit::FactAttribute]
        public void DeletePolicyTagResourceNames()
        {
            moq::Mock<PolicyTagManager.PolicyTagManagerClient> mockGrpcClient = new moq::Mock<PolicyTagManager.PolicyTagManagerClient>(moq::MockBehavior.Strict);
            DeletePolicyTagRequest request = new DeletePolicyTagRequest
            {
                PolicyTagName = PolicyTagName.FromProjectLocationTaxonomyPolicyTag("[PROJECT]", "[LOCATION]", "[TAXONOMY]", "[POLICY_TAG]"),
            };
            wkt::Empty expectedResponse = new wkt::Empty { };
            mockGrpcClient.Setup(x => x.DeletePolicyTag(request, moq::It.IsAny<grpccore::CallOptions>())).Returns(expectedResponse);
            PolicyTagManagerClient client = new PolicyTagManagerClientImpl(mockGrpcClient.Object, null, null);
            client.DeletePolicyTag(request.PolicyTagName);
            mockGrpcClient.VerifyAll();
        }

        [xunit::FactAttribute]
        public async stt::Task DeletePolicyTagResourceNamesAsync()
        {
            moq::Mock<PolicyTagManager.PolicyTagManagerClient> mockGrpcClient = new moq::Mock<PolicyTagManager.PolicyTagManagerClient>(moq::MockBehavior.Strict);
            DeletePolicyTagRequest request = new DeletePolicyTagRequest
            {
                PolicyTagName = PolicyTagName.FromProjectLocationTaxonomyPolicyTag("[PROJECT]", "[LOCATION]", "[TAXONOMY]", "[POLICY_TAG]"),
            };
            wkt::Empty expectedResponse = new wkt::Empty { };
            mockGrpcClient.Setup(x => x.DeletePolicyTagAsync(request, moq::It.IsAny<grpccore::CallOptions>())).Returns(new grpccore::AsyncUnaryCall<wkt::Empty>(stt::Task.FromResult(expectedResponse), null, null, null, null));
            PolicyTagManagerClient client = new PolicyTagManagerClientImpl(mockGrpcClient.Object, null, null);
            await client.DeletePolicyTagAsync(request.PolicyTagName, gaxgrpc::CallSettings.FromCancellationToken(st::CancellationToken.None));
            await client.DeletePolicyTagAsync(request.PolicyTagName, st::CancellationToken.None);
            mockGrpcClient.VerifyAll();
        }

        [xunit::FactAttribute]
        public void UpdatePolicyTagRequestObject()
        {
            moq::Mock<PolicyTagManager.PolicyTagManagerClient> mockGrpcClient = new moq::Mock<PolicyTagManager.PolicyTagManagerClient>(moq::MockBehavior.Strict);
            UpdatePolicyTagRequest request = new UpdatePolicyTagRequest
            {
                PolicyTag = new PolicyTag(),
                UpdateMask = new wkt::FieldMask(),
            };
            PolicyTag expectedResponse = new PolicyTag
            {
                PolicyTagName = PolicyTagName.FromProjectLocationTaxonomyPolicyTag("[PROJECT]", "[LOCATION]", "[TAXONOMY]", "[POLICY_TAG]"),
                DisplayName = "display_name137f65c2",
                Description = "description2cf9da67",
                ParentPolicyTag = "parent_policy_tagbc591931",
                ChildPolicyTags =
                {
                    "child_policy_tags11be0699",
                },
            };
            mockGrpcClient.Setup(x => x.UpdatePolicyTag(request, moq::It.IsAny<grpccore::CallOptions>())).Returns(expectedResponse);
            PolicyTagManagerClient client = new PolicyTagManagerClientImpl(mockGrpcClient.Object, null, null);
            PolicyTag response = client.UpdatePolicyTag(request);
            xunit::Assert.Same(expectedResponse, response);
            mockGrpcClient.VerifyAll();
        }

        [xunit::FactAttribute]
        public async stt::Task UpdatePolicyTagRequestObjectAsync()
        {
            moq::Mock<PolicyTagManager.PolicyTagManagerClient> mockGrpcClient = new moq::Mock<PolicyTagManager.PolicyTagManagerClient>(moq::MockBehavior.Strict);
            UpdatePolicyTagRequest request = new UpdatePolicyTagRequest
            {
                PolicyTag = new PolicyTag(),
                UpdateMask = new wkt::FieldMask(),
            };
            PolicyTag expectedResponse = new PolicyTag
            {
                PolicyTagName = PolicyTagName.FromProjectLocationTaxonomyPolicyTag("[PROJECT]", "[LOCATION]", "[TAXONOMY]", "[POLICY_TAG]"),
                DisplayName = "display_name137f65c2",
                Description = "description2cf9da67",
                ParentPolicyTag = "parent_policy_tagbc591931",
                ChildPolicyTags =
                {
                    "child_policy_tags11be0699",
                },
            };
            mockGrpcClient.Setup(x => x.UpdatePolicyTagAsync(request, moq::It.IsAny<grpccore::CallOptions>())).Returns(new grpccore::AsyncUnaryCall<PolicyTag>(stt::Task.FromResult(expectedResponse), null, null, null, null));
            PolicyTagManagerClient client = new PolicyTagManagerClientImpl(mockGrpcClient.Object, null, null);
            PolicyTag responseCallSettings = await client.UpdatePolicyTagAsync(request, gaxgrpc::CallSettings.FromCancellationToken(st::CancellationToken.None));
            xunit::Assert.Same(expectedResponse, responseCallSettings);
            PolicyTag responseCancellationToken = await client.UpdatePolicyTagAsync(request, st::CancellationToken.None);
            xunit::Assert.Same(expectedResponse, responseCancellationToken);
            mockGrpcClient.VerifyAll();
        }

        [xunit::FactAttribute]
        public void UpdatePolicyTag()
        {
            moq::Mock<PolicyTagManager.PolicyTagManagerClient> mockGrpcClient = new moq::Mock<PolicyTagManager.PolicyTagManagerClient>(moq::MockBehavior.Strict);
            UpdatePolicyTagRequest request = new UpdatePolicyTagRequest
            {
                PolicyTag = new PolicyTag(),
            };
            PolicyTag expectedResponse = new PolicyTag
            {
                PolicyTagName = PolicyTagName.FromProjectLocationTaxonomyPolicyTag("[PROJECT]", "[LOCATION]", "[TAXONOMY]", "[POLICY_TAG]"),
                DisplayName = "display_name137f65c2",
                Description = "description2cf9da67",
                ParentPolicyTag = "parent_policy_tagbc591931",
                ChildPolicyTags =
                {
                    "child_policy_tags11be0699",
                },
            };
            mockGrpcClient.Setup(x => x.UpdatePolicyTag(request, moq::It.IsAny<grpccore::CallOptions>())).Returns(expectedResponse);
            PolicyTagManagerClient client = new PolicyTagManagerClientImpl(mockGrpcClient.Object, null, null);
            PolicyTag response = client.UpdatePolicyTag(request.PolicyTag);
            xunit::Assert.Same(expectedResponse, response);
            mockGrpcClient.VerifyAll();
        }

        [xunit::FactAttribute]
        public async stt::Task UpdatePolicyTagAsync()
        {
            moq::Mock<PolicyTagManager.PolicyTagManagerClient> mockGrpcClient = new moq::Mock<PolicyTagManager.PolicyTagManagerClient>(moq::MockBehavior.Strict);
            UpdatePolicyTagRequest request = new UpdatePolicyTagRequest
            {
                PolicyTag = new PolicyTag(),
            };
            PolicyTag expectedResponse = new PolicyTag
            {
                PolicyTagName = PolicyTagName.FromProjectLocationTaxonomyPolicyTag("[PROJECT]", "[LOCATION]", "[TAXONOMY]", "[POLICY_TAG]"),
                DisplayName = "display_name137f65c2",
                Description = "description2cf9da67",
                ParentPolicyTag = "parent_policy_tagbc591931",
                ChildPolicyTags =
                {
                    "child_policy_tags11be0699",
                },
            };
            mockGrpcClient.Setup(x => x.UpdatePolicyTagAsync(request, moq::It.IsAny<grpccore::CallOptions>())).Returns(new grpccore::AsyncUnaryCall<PolicyTag>(stt::Task.FromResult(expectedResponse), null, null, null, null));
            PolicyTagManagerClient client = new PolicyTagManagerClientImpl(mockGrpcClient.Object, null, null);
            PolicyTag responseCallSettings = await client.UpdatePolicyTagAsync(request.PolicyTag, gaxgrpc::CallSettings.FromCancellationToken(st::CancellationToken.None));
            xunit::Assert.Same(expectedResponse, responseCallSettings);
            PolicyTag responseCancellationToken = await client.UpdatePolicyTagAsync(request.PolicyTag, st::CancellationToken.None);
            xunit::Assert.Same(expectedResponse, responseCancellationToken);
            mockGrpcClient.VerifyAll();
        }

        [xunit::FactAttribute]
        public void GetPolicyTagRequestObject()
        {
            moq::Mock<PolicyTagManager.PolicyTagManagerClient> mockGrpcClient = new moq::Mock<PolicyTagManager.PolicyTagManagerClient>(moq::MockBehavior.Strict);
            GetPolicyTagRequest request = new GetPolicyTagRequest
            {
                PolicyTagName = PolicyTagName.FromProjectLocationTaxonomyPolicyTag("[PROJECT]", "[LOCATION]", "[TAXONOMY]", "[POLICY_TAG]"),
            };
            PolicyTag expectedResponse = new PolicyTag
            {
                PolicyTagName = PolicyTagName.FromProjectLocationTaxonomyPolicyTag("[PROJECT]", "[LOCATION]", "[TAXONOMY]", "[POLICY_TAG]"),
                DisplayName = "display_name137f65c2",
                Description = "description2cf9da67",
                ParentPolicyTag = "parent_policy_tagbc591931",
                ChildPolicyTags =
                {
                    "child_policy_tags11be0699",
                },
            };
            mockGrpcClient.Setup(x => x.GetPolicyTag(request, moq::It.IsAny<grpccore::CallOptions>())).Returns(expectedResponse);
            PolicyTagManagerClient client = new PolicyTagManagerClientImpl(mockGrpcClient.Object, null, null);
            PolicyTag response = client.GetPolicyTag(request);
            xunit::Assert.Same(expectedResponse, response);
            mockGrpcClient.VerifyAll();
        }

        [xunit::FactAttribute]
        public async stt::Task GetPolicyTagRequestObjectAsync()
        {
            moq::Mock<PolicyTagManager.PolicyTagManagerClient> mockGrpcClient = new moq::Mock<PolicyTagManager.PolicyTagManagerClient>(moq::MockBehavior.Strict);
            GetPolicyTagRequest request = new GetPolicyTagRequest
            {
                PolicyTagName = PolicyTagName.FromProjectLocationTaxonomyPolicyTag("[PROJECT]", "[LOCATION]", "[TAXONOMY]", "[POLICY_TAG]"),
            };
            PolicyTag expectedResponse = new PolicyTag
            {
                PolicyTagName = PolicyTagName.FromProjectLocationTaxonomyPolicyTag("[PROJECT]", "[LOCATION]", "[TAXONOMY]", "[POLICY_TAG]"),
                DisplayName = "display_name137f65c2",
                Description = "description2cf9da67",
                ParentPolicyTag = "parent_policy_tagbc591931",
                ChildPolicyTags =
                {
                    "child_policy_tags11be0699",
                },
            };
            mockGrpcClient.Setup(x => x.GetPolicyTagAsync(request, moq::It.IsAny<grpccore::CallOptions>())).Returns(new grpccore::AsyncUnaryCall<PolicyTag>(stt::Task.FromResult(expectedResponse), null, null, null, null));
            PolicyTagManagerClient client = new PolicyTagManagerClientImpl(mockGrpcClient.Object, null, null);
            PolicyTag responseCallSettings = await client.GetPolicyTagAsync(request, gaxgrpc::CallSettings.FromCancellationToken(st::CancellationToken.None));
            xunit::Assert.Same(expectedResponse, responseCallSettings);
            PolicyTag responseCancellationToken = await client.GetPolicyTagAsync(request, st::CancellationToken.None);
            xunit::Assert.Same(expectedResponse, responseCancellationToken);
            mockGrpcClient.VerifyAll();
        }

        [xunit::FactAttribute]
        public void GetPolicyTag()
        {
            moq::Mock<PolicyTagManager.PolicyTagManagerClient> mockGrpcClient = new moq::Mock<PolicyTagManager.PolicyTagManagerClient>(moq::MockBehavior.Strict);
            GetPolicyTagRequest request = new GetPolicyTagRequest
            {
                PolicyTagName = PolicyTagName.FromProjectLocationTaxonomyPolicyTag("[PROJECT]", "[LOCATION]", "[TAXONOMY]", "[POLICY_TAG]"),
            };
            PolicyTag expectedResponse = new PolicyTag
            {
                PolicyTagName = PolicyTagName.FromProjectLocationTaxonomyPolicyTag("[PROJECT]", "[LOCATION]", "[TAXONOMY]", "[POLICY_TAG]"),
                DisplayName = "display_name137f65c2",
                Description = "description2cf9da67",
                ParentPolicyTag = "parent_policy_tagbc591931",
                ChildPolicyTags =
                {
                    "child_policy_tags11be0699",
                },
            };
            mockGrpcClient.Setup(x => x.GetPolicyTag(request, moq::It.IsAny<grpccore::CallOptions>())).Returns(expectedResponse);
            PolicyTagManagerClient client = new PolicyTagManagerClientImpl(mockGrpcClient.Object, null, null);
            PolicyTag response = client.GetPolicyTag(request.Name);
            xunit::Assert.Same(expectedResponse, response);
            mockGrpcClient.VerifyAll();
        }

        [xunit::FactAttribute]
        public async stt::Task GetPolicyTagAsync()
        {
            moq::Mock<PolicyTagManager.PolicyTagManagerClient> mockGrpcClient = new moq::Mock<PolicyTagManager.PolicyTagManagerClient>(moq::MockBehavior.Strict);
            GetPolicyTagRequest request = new GetPolicyTagRequest
            {
                PolicyTagName = PolicyTagName.FromProjectLocationTaxonomyPolicyTag("[PROJECT]", "[LOCATION]", "[TAXONOMY]", "[POLICY_TAG]"),
            };
            PolicyTag expectedResponse = new PolicyTag
            {
                PolicyTagName = PolicyTagName.FromProjectLocationTaxonomyPolicyTag("[PROJECT]", "[LOCATION]", "[TAXONOMY]", "[POLICY_TAG]"),
                DisplayName = "display_name137f65c2",
                Description = "description2cf9da67",
                ParentPolicyTag = "parent_policy_tagbc591931",
                ChildPolicyTags =
                {
                    "child_policy_tags11be0699",
                },
            };
            mockGrpcClient.Setup(x => x.GetPolicyTagAsync(request, moq::It.IsAny<grpccore::CallOptions>())).Returns(new grpccore::AsyncUnaryCall<PolicyTag>(stt::Task.FromResult(expectedResponse), null, null, null, null));
            PolicyTagManagerClient client = new PolicyTagManagerClientImpl(mockGrpcClient.Object, null, null);
            PolicyTag responseCallSettings = await client.GetPolicyTagAsync(request.Name, gaxgrpc::CallSettings.FromCancellationToken(st::CancellationToken.None));
            xunit::Assert.Same(expectedResponse, responseCallSettings);
            PolicyTag responseCancellationToken = await client.GetPolicyTagAsync(request.Name, st::CancellationToken.None);
            xunit::Assert.Same(expectedResponse, responseCancellationToken);
            mockGrpcClient.VerifyAll();
        }

        [xunit::FactAttribute]
        public void GetPolicyTagResourceNames()
        {
            moq::Mock<PolicyTagManager.PolicyTagManagerClient> mockGrpcClient = new moq::Mock<PolicyTagManager.PolicyTagManagerClient>(moq::MockBehavior.Strict);
            GetPolicyTagRequest request = new GetPolicyTagRequest
            {
                PolicyTagName = PolicyTagName.FromProjectLocationTaxonomyPolicyTag("[PROJECT]", "[LOCATION]", "[TAXONOMY]", "[POLICY_TAG]"),
            };
            PolicyTag expectedResponse = new PolicyTag
            {
                PolicyTagName = PolicyTagName.FromProjectLocationTaxonomyPolicyTag("[PROJECT]", "[LOCATION]", "[TAXONOMY]", "[POLICY_TAG]"),
                DisplayName = "display_name137f65c2",
                Description = "description2cf9da67",
                ParentPolicyTag = "parent_policy_tagbc591931",
                ChildPolicyTags =
                {
                    "child_policy_tags11be0699",
                },
            };
            mockGrpcClient.Setup(x => x.GetPolicyTag(request, moq::It.IsAny<grpccore::CallOptions>())).Returns(expectedResponse);
            PolicyTagManagerClient client = new PolicyTagManagerClientImpl(mockGrpcClient.Object, null, null);
            PolicyTag response = client.GetPolicyTag(request.PolicyTagName);
            xunit::Assert.Same(expectedResponse, response);
            mockGrpcClient.VerifyAll();
        }

        [xunit::FactAttribute]
        public async stt::Task GetPolicyTagResourceNamesAsync()
        {
            moq::Mock<PolicyTagManager.PolicyTagManagerClient> mockGrpcClient = new moq::Mock<PolicyTagManager.PolicyTagManagerClient>(moq::MockBehavior.Strict);
            GetPolicyTagRequest request = new GetPolicyTagRequest
            {
                PolicyTagName = PolicyTagName.FromProjectLocationTaxonomyPolicyTag("[PROJECT]", "[LOCATION]", "[TAXONOMY]", "[POLICY_TAG]"),
            };
            PolicyTag expectedResponse = new PolicyTag
            {
                PolicyTagName = PolicyTagName.FromProjectLocationTaxonomyPolicyTag("[PROJECT]", "[LOCATION]", "[TAXONOMY]", "[POLICY_TAG]"),
                DisplayName = "display_name137f65c2",
                Description = "description2cf9da67",
                ParentPolicyTag = "parent_policy_tagbc591931",
                ChildPolicyTags =
                {
                    "child_policy_tags11be0699",
                },
            };
            mockGrpcClient.Setup(x => x.GetPolicyTagAsync(request, moq::It.IsAny<grpccore::CallOptions>())).Returns(new grpccore::AsyncUnaryCall<PolicyTag>(stt::Task.FromResult(expectedResponse), null, null, null, null));
            PolicyTagManagerClient client = new PolicyTagManagerClientImpl(mockGrpcClient.Object, null, null);
            PolicyTag responseCallSettings = await client.GetPolicyTagAsync(request.PolicyTagName, gaxgrpc::CallSettings.FromCancellationToken(st::CancellationToken.None));
            xunit::Assert.Same(expectedResponse, responseCallSettings);
            PolicyTag responseCancellationToken = await client.GetPolicyTagAsync(request.PolicyTagName, st::CancellationToken.None);
            xunit::Assert.Same(expectedResponse, responseCancellationToken);
            mockGrpcClient.VerifyAll();
        }

        [xunit::FactAttribute]
        public void GetIamPolicyRequestObject()
        {
            moq::Mock<PolicyTagManager.PolicyTagManagerClient> mockGrpcClient = new moq::Mock<PolicyTagManager.PolicyTagManagerClient>(moq::MockBehavior.Strict);
            gciv::GetIamPolicyRequest request = new gciv::GetIamPolicyRequest
            {
                ResourceAsResourceName = new gax::UnparsedResourceName("a/wildcard/resource"),
                Options = new gciv::GetPolicyOptions(),
            };
            gciv::Policy expectedResponse = new gciv::Policy
            {
                Version = 271578922,
                Etag = proto::ByteString.CopyFromUtf8("etage8ad7218"),
                Bindings =
                {
                    new gciv::Binding(),
                },
                AuditConfigs =
                {
                    new gciv::AuditConfig(),
                },
            };
            mockGrpcClient.Setup(x => x.GetIamPolicy(request, moq::It.IsAny<grpccore::CallOptions>())).Returns(expectedResponse);
            PolicyTagManagerClient client = new PolicyTagManagerClientImpl(mockGrpcClient.Object, null, null);
            gciv::Policy response = client.GetIamPolicy(request);
            xunit::Assert.Same(expectedResponse, response);
            mockGrpcClient.VerifyAll();
        }

        [xunit::FactAttribute]
        public async stt::Task GetIamPolicyRequestObjectAsync()
        {
            moq::Mock<PolicyTagManager.PolicyTagManagerClient> mockGrpcClient = new moq::Mock<PolicyTagManager.PolicyTagManagerClient>(moq::MockBehavior.Strict);
            gciv::GetIamPolicyRequest request = new gciv::GetIamPolicyRequest
            {
                ResourceAsResourceName = new gax::UnparsedResourceName("a/wildcard/resource"),
                Options = new gciv::GetPolicyOptions(),
            };
            gciv::Policy expectedResponse = new gciv::Policy
            {
                Version = 271578922,
                Etag = proto::ByteString.CopyFromUtf8("etage8ad7218"),
                Bindings =
                {
                    new gciv::Binding(),
                },
                AuditConfigs =
                {
                    new gciv::AuditConfig(),
                },
            };
            mockGrpcClient.Setup(x => x.GetIamPolicyAsync(request, moq::It.IsAny<grpccore::CallOptions>())).Returns(new grpccore::AsyncUnaryCall<gciv::Policy>(stt::Task.FromResult(expectedResponse), null, null, null, null));
            PolicyTagManagerClient client = new PolicyTagManagerClientImpl(mockGrpcClient.Object, null, null);
            gciv::Policy responseCallSettings = await client.GetIamPolicyAsync(request, gaxgrpc::CallSettings.FromCancellationToken(st::CancellationToken.None));
            xunit::Assert.Same(expectedResponse, responseCallSettings);
            gciv::Policy responseCancellationToken = await client.GetIamPolicyAsync(request, st::CancellationToken.None);
            xunit::Assert.Same(expectedResponse, responseCancellationToken);
            mockGrpcClient.VerifyAll();
        }

        [xunit::FactAttribute]
        public void SetIamPolicyRequestObject()
        {
            moq::Mock<PolicyTagManager.PolicyTagManagerClient> mockGrpcClient = new moq::Mock<PolicyTagManager.PolicyTagManagerClient>(moq::MockBehavior.Strict);
            gciv::SetIamPolicyRequest request = new gciv::SetIamPolicyRequest
            {
                ResourceAsResourceName = new gax::UnparsedResourceName("a/wildcard/resource"),
                Policy = new gciv::Policy(),
                UpdateMask = new wkt::FieldMask(),
            };
            gciv::Policy expectedResponse = new gciv::Policy
            {
                Version = 271578922,
                Etag = proto::ByteString.CopyFromUtf8("etage8ad7218"),
                Bindings =
                {
                    new gciv::Binding(),
                },
                AuditConfigs =
                {
                    new gciv::AuditConfig(),
                },
            };
            mockGrpcClient.Setup(x => x.SetIamPolicy(request, moq::It.IsAny<grpccore::CallOptions>())).Returns(expectedResponse);
            PolicyTagManagerClient client = new PolicyTagManagerClientImpl(mockGrpcClient.Object, null, null);
            gciv::Policy response = client.SetIamPolicy(request);
            xunit::Assert.Same(expectedResponse, response);
            mockGrpcClient.VerifyAll();
        }

        [xunit::FactAttribute]
        public async stt::Task SetIamPolicyRequestObjectAsync()
        {
            moq::Mock<PolicyTagManager.PolicyTagManagerClient> mockGrpcClient = new moq::Mock<PolicyTagManager.PolicyTagManagerClient>(moq::MockBehavior.Strict);
            gciv::SetIamPolicyRequest request = new gciv::SetIamPolicyRequest
            {
                ResourceAsResourceName = new gax::UnparsedResourceName("a/wildcard/resource"),
                Policy = new gciv::Policy(),
                UpdateMask = new wkt::FieldMask(),
            };
            gciv::Policy expectedResponse = new gciv::Policy
            {
                Version = 271578922,
                Etag = proto::ByteString.CopyFromUtf8("etage8ad7218"),
                Bindings =
                {
                    new gciv::Binding(),
                },
                AuditConfigs =
                {
                    new gciv::AuditConfig(),
                },
            };
            mockGrpcClient.Setup(x => x.SetIamPolicyAsync(request, moq::It.IsAny<grpccore::CallOptions>())).Returns(new grpccore::AsyncUnaryCall<gciv::Policy>(stt::Task.FromResult(expectedResponse), null, null, null, null));
            PolicyTagManagerClient client = new PolicyTagManagerClientImpl(mockGrpcClient.Object, null, null);
            gciv::Policy responseCallSettings = await client.SetIamPolicyAsync(request, gaxgrpc::CallSettings.FromCancellationToken(st::CancellationToken.None));
            xunit::Assert.Same(expectedResponse, responseCallSettings);
            gciv::Policy responseCancellationToken = await client.SetIamPolicyAsync(request, st::CancellationToken.None);
            xunit::Assert.Same(expectedResponse, responseCancellationToken);
            mockGrpcClient.VerifyAll();
        }

        [xunit::FactAttribute]
        public void TestIamPermissionsRequestObject()
        {
            moq::Mock<PolicyTagManager.PolicyTagManagerClient> mockGrpcClient = new moq::Mock<PolicyTagManager.PolicyTagManagerClient>(moq::MockBehavior.Strict);
            gciv::TestIamPermissionsRequest request = new gciv::TestIamPermissionsRequest
            {
                ResourceAsResourceName = new gax::UnparsedResourceName("a/wildcard/resource"),
                Permissions =
                {
                    "permissions535a2741",
                },
            };
            gciv::TestIamPermissionsResponse expectedResponse = new gciv::TestIamPermissionsResponse
            {
                Permissions =
                {
                    "permissions535a2741",
                },
            };
            mockGrpcClient.Setup(x => x.TestIamPermissions(request, moq::It.IsAny<grpccore::CallOptions>())).Returns(expectedResponse);
            PolicyTagManagerClient client = new PolicyTagManagerClientImpl(mockGrpcClient.Object, null, null);
            gciv::TestIamPermissionsResponse response = client.TestIamPermissions(request);
            xunit::Assert.Same(expectedResponse, response);
            mockGrpcClient.VerifyAll();
        }

        [xunit::FactAttribute]
        public async stt::Task TestIamPermissionsRequestObjectAsync()
        {
            moq::Mock<PolicyTagManager.PolicyTagManagerClient> mockGrpcClient = new moq::Mock<PolicyTagManager.PolicyTagManagerClient>(moq::MockBehavior.Strict);
            gciv::TestIamPermissionsRequest request = new gciv::TestIamPermissionsRequest
            {
                ResourceAsResourceName = new gax::UnparsedResourceName("a/wildcard/resource"),
                Permissions =
                {
                    "permissions535a2741",
                },
            };
            gciv::TestIamPermissionsResponse expectedResponse = new gciv::TestIamPermissionsResponse
            {
                Permissions =
                {
                    "permissions535a2741",
                },
            };
            mockGrpcClient.Setup(x => x.TestIamPermissionsAsync(request, moq::It.IsAny<grpccore::CallOptions>())).Returns(new grpccore::AsyncUnaryCall<gciv::TestIamPermissionsResponse>(stt::Task.FromResult(expectedResponse), null, null, null, null));
            PolicyTagManagerClient client = new PolicyTagManagerClientImpl(mockGrpcClient.Object, null, null);
            gciv::TestIamPermissionsResponse responseCallSettings = await client.TestIamPermissionsAsync(request, gaxgrpc::CallSettings.FromCancellationToken(st::CancellationToken.None));
            xunit::Assert.Same(expectedResponse, responseCallSettings);
            gciv::TestIamPermissionsResponse responseCancellationToken = await client.TestIamPermissionsAsync(request, st::CancellationToken.None);
            xunit::Assert.Same(expectedResponse, responseCancellationToken);
            mockGrpcClient.VerifyAll();
        }
    }
}


text:
package nl.riebie.mcclans.config.model;

import javax.annotation.Nullable;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

/**
 * Created by Kippers on 22/12/2015.
 */
public class ConfigSection {

    public String key;
    public String comment;
    public List<ConfigOption> configOptions;

    public ConfigSection(String key, @Nullable String comment, List<ConfigOption> configOptions) {
        this.key = key;
        this.comment = comment;
        this.configOptions = configOptions;
    }

    public boolean hasComment() {
        return comment != null && comment.length() != 0;
    }

    public static Builder builder(String key) {
        return new Builder(key);
    }

    public static class Builder {
        private String key;
        private String comment = "";
        private List<ConfigOption> configOptions = new ArrayList<>();

        private Builder(String key) {
            this.key = key;
        }

        public Builder setComment(@Nullable String comment) {
            this.comment = comment;
            return this;
        }

        public Builder setConfigOptions(List<ConfigOption> configOptions) {
            this.configOptions = configOptions;
            return this;
        }

        public Builder setConfigOptions(ConfigOption... configOptions) {
            this.configOptions = Arrays.asList(configOptions);
            return this;
        }

        public ConfigSection build() {
            return new ConfigSection(key, comment, configOptions);
        }
    }
}