text:
package org.reactnative.camera.tasks;

import android.util.SparseArray;

import com.facebook.react.bridge.Arguments;
import com.facebook.react.bridge.WritableArray;
import com.facebook.react.bridge.WritableMap;
import com.google.android.cameraview.CameraView;
import com.google.android.gms.vision.face.Face;

import org.reactnative.camera.utils.ImageDimensions;
import org.reactnative.facedetector.FaceDetectorUtils;
import org.reactnative.frame.RNFrame;
import org.reactnative.frame.RNFrameFactory;
import org.reactnative.facedetector.RNFaceDetector;

public class FaceDetectorAsyncTask extends android.os.AsyncTask<Void, Void, SparseArray<Face>> {
  private byte[] mImageData;
  private int mWidth;
  private int mHeight;
  private int mRotation;
  private RNFaceDetector mFaceDetector;
  private FaceDetectorAsyncTaskDelegate mDelegate;
  private ImageDimensions mImageDimensions;
  private double mScaleX;
  private double mScaleY;
  private int mPaddingLeft;
  private int mPaddingTop;

  public FaceDetectorAsyncTask(
      FaceDetectorAsyncTaskDelegate delegate,
      RNFaceDetector faceDetector,
      byte[] imageData,
      int width,
      int height,
      int rotation,
      float density,
      int facing,
      int viewWidth,
      int viewHeight,
      int viewPaddingLeft,
      int viewPaddingTop
  ) {
    mImageData = imageData;
    mWidth = width;
    mHeight = height;
    mRotation = rotation;
    mDelegate = delegate;
    mFaceDetector = faceDetector;
    mImageDimensions = new ImageDimensions(width, height, rotation, facing);
    mScaleX = (double) (viewWidth) / (mImageDimensions.getWidth() * density);
    mScaleY = (double) (viewHeight) / (mImageDimensions.getHeight() * density);
    mPaddingLeft = viewPaddingLeft;
    mPaddingTop = viewPaddingTop;
  }

  @Override
  protected SparseArray<Face> doInBackground(Void... ignored) {
    if (isCancelled() || mDelegate == null || mFaceDetector == null || !mFaceDetector.isOperational()) {
      return null;
    }

    RNFrame frame = RNFrameFactory.buildFrame(mImageData, mWidth, mHeight, mRotation);
    return mFaceDetector.detect(frame);
  }

  @Override
  protected void onPostExecute(SparseArray<Face> faces) {
    super.onPostExecute(faces);

    if (faces == null) {
      mDelegate.onFaceDetectionError(mFaceDetector);
    } else {
      if (faces.size() > 0) {
        mDelegate.onFacesDetected(serializeEventData(faces));
      }
      mDelegate.onFaceDetectingTaskCompleted();
    }
  }

  private WritableArray serializeEventData(SparseArray<Face> faces) {
    WritableArray facesList = Arguments.createArray();

    for(int i = 0; i < faces.size(); i++) {
      Face face = faces.valueAt(i);
      WritableMap serializedFace = FaceDetectorUtils.serializeFace(face, mScaleX, mScaleY, mWidth, mHeight, mPaddingLeft, mPaddingTop);
      if (mImageDimensions.getFacing() == CameraView.FACING_FRONT) {
        serializedFace = FaceDetectorUtils.rotateFaceX(serializedFace, mImageDimensions.getWidth(), mScaleX);
      } else {
        serializedFace = FaceDetectorUtils.changeAnglesDirection(serializedFace);
      }
      facesList.pushMap(serializedFace);
    }

    return facesList;
  }
}


text:
package org.minimalj.example.minimalclinic.model;

import java.time.LocalDate;

import org.minimalj.model.Keys;
import org.minimalj.model.Rendering;
import org.minimalj.model.annotation.NotEmpty;
import org.minimalj.model.annotation.Size;
import org.minimalj.util.DateUtils;

public class Pet implements Rendering {
	public static final Pet $ = Keys.of(Pet.class);

	public Object id;

	public Owner owner;

	@NotEmpty @Size(30)
	public String name;

	@NotEmpty
    public LocalDate birthDate;

	@NotEmpty
	public PetType type;

    @Override
    public String render() {
    	return name + ", " + DateUtils.format(birthDate) + ", " + type.render();
    }

}

redpajama_set_name: RedPajamaGithub


text:
import functools
import types

import torch._C as _C

TensorProtoDataType = _C._onnx.TensorProtoDataType
OperatorExportTypes = _C._onnx.OperatorExportTypes
PYTORCH_ONNX_CAFFE2_BUNDLE = _C._onnx.PYTORCH_ONNX_CAFFE2_BUNDLE

ONNX_ARCHIVE_MODEL_PROTO_NAME = "__MODEL_PROTO"

class ExportTypes:
    PROTOBUF_FILE = 1
    ZIP_ARCHIVE = 2
    COMPRESSED_ZIP_ARCHIVE = 3
    DIRECTORY = 4

def _export(*args, **kwargs):
    from torch.onnx import utils
    return utils._export(*args, **kwargs)

def export(*args, **kwargs):
    from torch.onnx import utils
    return utils.export(*args, **kwargs)

def export_to_pretty_string(*args, **kwargs):
    from torch.onnx import utils
    return utils.export_to_pretty_string(*args, **kwargs)

def _export_to_pretty_string(*args, **kwargs):
    from torch.onnx import utils
    return utils._export_to_pretty_string(*args, **kwargs)

def _optimize_trace(trace, operator_export_type):
    from torch.onnx import utils
    trace.set_graph(utils._optimize_graph(trace.graph(), operator_export_type))

def set_training(*args, **kwargs):
    from torch.onnx import utils
    return utils.set_training(*args, **kwargs)

def _run_symbolic_function(*args, **kwargs):
    from torch.onnx import utils
    return utils._run_symbolic_function(*args, **kwargs)

def _run_symbolic_method(*args, **kwargs):
    from torch.onnx import utils
    return utils._run_symbolic_method(*args, **kwargs)


text:
<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context="com.srmhackathon.haasil.PaymentActivity">

    <TextView
        android:id="@+id/textView4"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_alignParentTop="true"
        android:layout_centerHorizontal="true"
        android:layout_marginTop="120dp"
        android:text="Enter the amount to pay"
        android:textAlignment="center"
        android:textSize="30sp"
        android:textStyle="bold" />

    <EditText
        android:id="@+id/editTextAmount"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_below="@+id/textView4"
        android:layout_centerHorizontal="true"
        android:layout_marginTop="88dp"
        android:ems="10"
        android:inputType="phone" />

    <Button
        android:id="@+id/button3"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_below="@+id/editTextAmount"
        android:layout_centerHorizontal="true"
        android:layout_marginTop="86dp"
        android:background="@color/cb_errorRed"
        android:text="Pay"
        android:onClick="navigateToBaseActivity"/>
</RelativeLayout>


text:
//
// Copyright (c) Microsoft.  All rights reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//   http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//

using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Net.Security;
using Hyak.Common;
using Microsoft.Azure.Management.Authorization;
using Microsoft.Azure.Management.Authorization.Models;
using Microsoft.Azure.Management.Resources;
using Microsoft.Azure.Test;
using Microsoft.Azure.Test.HttpRecorder;
using Xunit;

namespace Authorization.Tests
{
    public class BasicTests : TestBase, IUseFixture<TestExecutionContext>
    {
        private TestExecutionContext testContext;
        private const int RoleAssignmentPageSize = 20;

        public void SetFixture(TestExecutionContext context)
        {
            testContext = context;
        }

        [Fact]
        public void ClassicAdministratorListTests()
        {
            using (UndoContext context = UndoContext.Current)
            {
                context.Start();
                var client = testContext.GetAuthorizationManagementClient();

                Assert.NotNull(client);
                Assert.NotNull(client.HttpClient);

                var allClassicAdmins = client.ClassicAdministrators.List();

                Assert.NotNull(allClassicAdmins);
                Assert.NotNull(allClassicAdmins.ClassicAdministrators);

                foreach (var classicAdmin in allClassicAdmins.ClassicAdministrators)
                {
                    Assert.NotNull(classicAdmin);
                    Assert.NotNull(classicAdmin.Id);
                    Assert.True(classicAdmin.Id.Contains("/providers/Microsoft.Authorization/classicAdministrators/"));
                    Assert.True(classicAdmin.Id.Contains("/subscriptions/" + client.Credentials.SubscriptionId));
                    Assert.NotNull(classicAdmin.Name);
                    Assert.NotNull(classicAdmin.Type);
                    Assert.Equal("Microsoft.Authorization/classicAdministrators", classicAdmin.Type);
                    Assert.NotNull(classicAdmin.Properties);
                    Assert.NotNull(classicAdmin.Properties.EmailAddress);
                    Assert.NotNull(classicAdmin.Properties.Role);
                }
            }
        }

        [Fact]
        public void RoleAssignmentByIdTests()
        {
            using (UndoContext context = UndoContext.Current)
            {
                context.Start();

                var client = testContext.GetAuthorizationManagementClient();

                Assert.NotNull(client);
                Assert.NotNull(client.HttpClient);

                var principalId = testContext.Users.ElementAt(4);

                var roleDefinition = client.RoleDefinitions.List().RoleDefinitions.ElementAt(1);
                var newRoleAssignment = new RoleAssignmentCreateParameters()
                {
                    Properties = new RoleAssignmentProperties()
                    {
                        RoleDefinitionId = roleDefinition.Id,
                        PrincipalId = principalId
                    }
                };

                var scope = "subscriptions/" + client.Credentials.SubscriptionId;
                var assignmentName = GetValueFromTestContext(Guid.NewGuid, Guid.Parse, "AssignmentName");

                var assignmentId = string.Format(
                    "{0}/providers/Microsoft.Authorization/roleAssignments/{1}",
                    scope,
                    assignmentName);

                // Create
                var createResult = client.RoleAssignments.CreateById(assignmentId, newRoleAssignment);
                Assert.NotNull(createResult);
                Assert.Equal(HttpStatusCode.Created, createResult.StatusCode);
                Assert.NotNull(createResult.RoleAssignment);
                Assert.NotNull(createResult.RoleAssignment.Id);
                Assert.NotNull(createResult.RoleAssignment.Name);
                Assert.Equal(createResult.RoleAssignment.Name, assignmentName);

                // Get
                var getResult = client.RoleAssignments.GetById(assignmentId);
                Assert.NotNull(getResult);
                Assert.Equal(HttpStatusCode.OK, getResult.StatusCode);
                Assert.NotNull(getResult.RoleAssignment);
                Assert.Equal(createResult.RoleAssignment.Id, getResult.RoleAssignment.Id);
                Assert.Equal(createResult.RoleAssignment.Name, getResult.RoleAssignment.Name);

                //Delete
                var deleteResult = client.RoleAssignments.DeleteById(assignmentId);
                Assert.NotNull(deleteResult);
                Assert.Equal(HttpStatusCode.OK, deleteResult.StatusCode);

                var allRoleAssignments = client.RoleAssignments.List(null);
                var createdAssignment = allRoleAssignments.RoleAssignments.FirstOrDefault(
                                            a => a.Name == assignmentName);

                Assert.Null(createdAssignment);
            }
        }

        [Fact]
        public void RoleAssignmentsListGetTests()
        {
            using (UndoContext context = UndoContext.Current)
            {
                context.Start();

                var client = testContext.GetAuthorizationManagementClient();

                Assert.NotNull(client);
                Assert.NotNull(client.HttpClient);

                var assignmentName = GetValueFromTestContext(Guid.NewGuid, Guid.Parse, "AssignmentName");

                var scope = "subscriptions/" + client.Credentials.SubscriptionId;
                var principalId = testContext.Users.ElementAt(5);

                Assert.NotNull(client);
                Assert.NotNull(client.HttpClient);

                var roleDefinition = client.RoleDefinitions.List().RoleDefinitions.Where(r => r.Properties.Type == "BuiltInRole").Last();
                var newRoleAssignment = new RoleAssignmentCreateParameters()
                {
                    Properties = new RoleAssignmentProperties()
                    {
                        RoleDefinitionId = roleDefinition.Id,
                        PrincipalId = principalId
                    }
                };

                var createResult = client.RoleAssignments.Create(scope, assignmentName, newRoleAssignment);
                Assert.NotNull(createResult);

                var allRoleAssignments = client.RoleAssignments.List(null);

                Assert.NotNull(allRoleAssignments);
                Assert.NotNull(allRoleAssignments.RoleAssignments);

                foreach (var assignment in allRoleAssignments.RoleAssignments)
                {
                    var singleAssignment = client.RoleAssignments.Get(assignment.Properties.Scope, assignment.Name);

                    Assert.NotNull(singleAssignment);
                    Assert.NotNull(singleAssignment.StatusCode);
                    Assert.NotNull(singleAssignment.RoleAssignment);
                    Assert.NotNull(singleAssignment.RoleAssignment.Id);
                    Assert.NotNull(singleAssignment.RoleAssignment.Name);
                    Assert.NotNull(singleAssignment.RoleAssignment.Type);
                    Assert.NotNull(singleAssignment.RoleAssignment.Properties);
                    Assert.NotNull(singleAssignment.RoleAssignment.Properties.PrincipalId);
                    Assert.NotNull(singleAssignment.RoleAssignment.Properties.RoleDefinitionId);
                    Assert.NotNull(singleAssignment.RoleAssignment.Properties.Scope);
                }

                var deleteResult = client.RoleAssignments.Delete(scope, assignmentName);
                Assert.NotNull(deleteResult);
            }
        }

        [Fact]
        public void RoleAssignmentsCreateDeleteTests()
        {
            using (UndoContext context = UndoContext.Current)
            {
                context.Start();

                var client = testContext.GetAuthorizationManagementClient();

                var assignmentName = GetValueFromTestContext(Guid.NewGuid, Guid.Parse, "AssignmentName");

                var scope = "subscriptions/" + client.Credentials.SubscriptionId;
                var principalId = testContext.Users.ElementAt(3);

                Assert.NotNull(client);
                Assert.NotNull(client.HttpClient);

                var roleDefinition = client.RoleDefinitions.List().RoleDefinitions.Last();
                var newRoleAssignment = new RoleAssignmentCreateParameters()
                {
                    Properties = new RoleAssignmentProperties()
                    {
                        RoleDefinitionId = roleDefinition.Id,
                        PrincipalId = principalId
                    }
                };

                var createResult = client.RoleAssignments.Create(scope, assignmentName, newRoleAssignment);
                Assert.NotNull(createResult);
                Assert.Equal(HttpStatusCode.Created, createResult.StatusCode);
                Assert.NotNull(createResult.RoleAssignment);

                var deleteResult = client.RoleAssignments.Delete(scope, assignmentName);
                Assert.NotNull(deleteResult);
                Assert.Equal(HttpStatusCode.OK, deleteResult.StatusCode);
                var deletedRoleAssignment = deleteResult.RoleAssignment;
                Assert.NotNull(deletedRoleAssignment);
                Assert.Equal(deletedRoleAssignment.Id, createResult.RoleAssignment.Id);

                var allRoleAssignments = client.RoleAssignments.List(null);
                var createdAssignment = allRoleAssignments.RoleAssignments.FirstOrDefault(
                                            a => a.Name == assignmentName);

                Assert.Null(createdAssignment);
            }
        }

        [Fact]
        public void RoleAssignmentAtScopeAndAboveTest()
        {
            using (UndoContext context = UndoContext.Current)
            {
                context.Start();
                var client = testContext.GetAuthorizationManagementClient();

                Assert.NotNull(client);
                Assert.NotNull(client.HttpClient);

                var allRoleAssignments = client.RoleAssignments.List(new ListAssignmentsFilterParameters
                    {
                        AtScope = true,
                    });

                Assert.NotNull(allRoleAssignments);
                Assert.NotNull(allRoleAssignments.RoleAssignments);

                foreach (var assignment in allRoleAssignments.RoleAssignments)
                {
                    Assert.NotNull(assignment);
                    Assert.NotNull(assignment.Id);
                    Assert.NotNull(assignment.Name);
                    Assert.NotNull(assignment.Type);
                    Assert.NotNull(assignment.Properties);
                    Assert.NotNull(assignment.Properties.PrincipalId);
                    Assert.NotNull(assignment.Properties.RoleDefinitionId);
                    Assert.NotNull(assignment.Properties.Scope);
                }
            }
        }

        [Fact]
        public void RoleAssignmentListByFilterTest()
        {
            using (UndoContext context = UndoContext.Current)
            {
                context.Start();
                var client = testContext.GetAuthorizationManagementClient();
                Assert.NotNull(client);
                Assert.NotNull(client.HttpClient);

                var principalId = testContext.Users.ElementAt(1);
                // Read/write the PrincipalId from Testcontext to enable Playback mode test execution
                principalId = GetValueFromTestContext(() => principalId, Guid.Parse, "PrincipalId");

                var scope = "subscriptions/" + client.Credentials.SubscriptionId;
                var roleDefinition = client.RoleDefinitions.List().RoleDefinitions.First();

                for(int i=0; i<testContext.Users.Count; i++)
                {
                    var pId = testContext.Users.ElementAt(i);
                    var newRoleAssignment = new RoleAssignmentCreateParameters()
                    {
                        Properties = new RoleAssignmentProperties()
                        {
                            RoleDefinitionId = roleDefinition.Id,
                            PrincipalId = pId
                        }
                    };
                    var assignmentName = GetValueFromTestContext(Guid.NewGuid, Guid.Parse, "AssignmentName_" + i);
                    var createResult = client.RoleAssignments.Create(scope, assignmentName, newRoleAssignment);
                }

                var allRoleAssignments = client.RoleAssignments.List(new ListAssignmentsFilterParameters
                    {
                        PrincipalId = principalId
                    });

                Assert.NotNull(allRoleAssignments);
                Assert.NotNull(allRoleAssignments.RoleAssignments);

                foreach (var assignment in allRoleAssignments.RoleAssignments)
                {
                    Assert.NotNull(assignment);
                    Assert.NotNull(assignment.Id);
                    Assert.NotNull(assignment.Name);
                    Assert.NotNull(assignment.Type);
                    Assert.NotNull(assignment.Properties);
                    Assert.NotNull(assignment.Properties.PrincipalId);
                    Assert.NotNull(assignment.Properties.RoleDefinitionId);
                    Assert.NotNull(assignment.Properties.Scope);

                    Assert.Equal(principalId, assignment.Properties.PrincipalId);
                }
            }
        }

        [Fact]
        public void RoleAssignmentPagingTest()
        {
            using (UndoContext context = UndoContext.Current)
            {
                context.Start();
                var client = testContext.GetAuthorizationManagementClient();

                Assert.NotNull(client);
                Assert.NotNull(client.HttpClient);

                var scope = "subscriptions/" + client.Credentials.SubscriptionId;
                var allBuiltInRoles = client.RoleDefinitions.List().RoleDefinitions.Where(r => r.Properties.Type.Equals("BuiltInRole", StringComparison.OrdinalIgnoreCase));
                var allBuiltInRolesList = allBuiltInRoles as IList<RoleDefinition> ?? allBuiltInRoles.ToList();
                int roleCount = allBuiltInRolesList.Count();
                int userCount = testContext.Users.Count();

                List<RoleAssignment> createdAssignments = new List<RoleAssignment>();

                try
                {
                    for (int i = 0; i < RoleAssignmentPageSize + 2; i++)
                    {
                        Random random = new Random();

                        // Get random user
                        int userIndex = random.Next(0, userCount);
                        var principalId = testContext.Users.ElementAt(userIndex);

                        // Get random built-in role definition
                        int roleIndex = random.Next(0, roleCount);
                        var roleDefinition = allBuiltInRolesList.ElementAt(roleIndex);

                        var newRoleAssignment = new RoleAssignmentCreateParameters()
                        {
                            Properties = new RoleAssignmentProperties()
                            {
                                RoleDefinitionId = roleDefinition.Id,
                                PrincipalId = principalId
                            }
                        };
                        var assignmentName = GetValueFromTestContext(Guid.NewGuid, Guid.Parse, "AssignmentName_" + i);
                        RoleAssignmentCreateResult createResult = null;
                        try
                        {
                            createResult = client.RoleAssignments.Create(scope, assignmentName, newRoleAssignment);
                        }
                        catch (CloudException e)
                        {
                            if (e.Response.StatusCode == HttpStatusCode.Conflict)
                            {
                                i--;
                                continue;
                            }
                        }

                        Assert.NotNull(createResult);
                        Assert.NotNull(createResult.RoleAssignment);
                        createdAssignments.Add(createResult.RoleAssignment);
                    }

                    // Validate

                    // Get the first page of assignments
                    var firstPage = client.RoleAssignments.List(null);
                    Assert.NotNull(firstPage);
                    Assert.True(firstPage.StatusCode == HttpStatusCode.OK);
                    Assert.NotNull(firstPage.RoleAssignments);
                    Assert.NotNull(firstPage.NextLink);

                    // Get the next page of assignments
                    var nextPage = client.RoleAssignments.ListNext(firstPage.NextLink);

                    Assert.True(nextPage.StatusCode == HttpStatusCode.OK);
                    Assert.NotNull(nextPage.RoleAssignments);
                    Assert.NotEqual(0, nextPage.RoleAssignments.Count());

                    foreach (var roleAssignment in nextPage.RoleAssignments)
                    {
                        Assert.NotNull(roleAssignment);
                        Assert.NotNull(roleAssignment.Id);
                        Assert.NotNull(roleAssignment.Name);
                        Assert.NotNull(roleAssignment.Type);
                        Assert.NotNull(roleAssignment.Properties);
                        Assert.NotNull(roleAssignment.Properties.PrincipalId);
                        Assert.NotNull(roleAssignment.Properties.RoleDefinitionId);
                        Assert.NotNull(roleAssignment.Properties.Scope);
                    }
                }
                finally
                {
                    foreach (var createdAssignment in createdAssignments)
                    {
                        client.RoleAssignments.Delete(createdAssignment.Properties.Scope, createdAssignment.Name);
                    }
                }
            }
        }

        [Fact]
        public void RoleAssignmentListForScopeTest()
        {
            using (UndoContext context = UndoContext.Current)
            {
                context.Start();
                var client = testContext.GetAuthorizationManagementClient();

                Assert.NotNull(client);
                Assert.NotNull(client.HttpClient);

                var allRoleAssignments = client.RoleAssignments.ListForScope(
                    "subscriptions/" + client.Credentials.SubscriptionId,
                    new ListAssignmentsFilterParameters
                    {
                        AtScope = true
                    });

                Assert.NotNull(allRoleAssignments);
                Assert.NotNull(allRoleAssignments.RoleAssignments);

                foreach (var assignment in allRoleAssignments.RoleAssignments)
                {
                    Assert.NotNull(assignment);
                    Assert.NotNull(assignment.Id);
                    Assert.NotNull(assignment.Name);
                    Assert.NotNull(assignment.Type);
                    Assert.NotNull(assignment.Properties);
                    Assert.NotNull(assignment.Properties.PrincipalId);
                    Assert.NotNull(assignment.Properties.RoleDefinitionId);
                    Assert.NotNull(assignment.Properties.Scope);
                }
            }
        }

        [Fact(Skip = "Graph issue when adding user to group, needs investigation")]
        public void RoleAssignmentListWithAssignedToFilterTest()
        {
            using (UndoContext context = UndoContext.Current)
            {
                context.Start();
                var client = testContext.GetAuthorizationManagementClient();

                Assert.NotNull(client);
                Assert.NotNull(client.HttpClient);

                var scope = "subscriptions/" + client.Credentials.SubscriptionId;
                var roleDefinition = client.RoleDefinitions.List().RoleDefinitions.First();

                // Get user and group and add the user to the group
                var userId = testContext.Users.First();
                var groupId = testContext.Groups.First();
                testContext.AddMemberToGroup(groupId, userId.ToString());

                // create assignment to group
                var newRoleAssignmentToGroupParams = new RoleAssignmentCreateParameters()
                {
                    Properties = new RoleAssignmentProperties()
                    {
                        RoleDefinitionId = roleDefinition.Id,
                        PrincipalId = Guid.Parse(groupId)
                    }
                };
                var assignmentName = GetValueFromTestContext(Guid.NewGuid, Guid.Parse, "AssignmentName_Group");
                var assignmentToGroup = client.RoleAssignments.Create(scope, assignmentName, newRoleAssignmentToGroupParams);

                // create assignment to user
                var newRoleAssignmentToUserParams = new RoleAssignmentCreateParameters()
                {
                    Properties = new RoleAssignmentProperties()
                    {
                        RoleDefinitionId = roleDefinition.Id,
                        PrincipalId = userId
                    }
                };

                assignmentName = GetValueFromTestContext(Guid.NewGuid, Guid.Parse, "AssignmentName_User");
                var assignmentToUser = client.RoleAssignments.Create(scope, assignmentName, newRoleAssignmentToUserParams);

                // List role assignments with AssignedTo filter = user id
                var allRoleAssignments = client.RoleAssignments.List(new ListAssignmentsFilterParameters
                {
                    AssignedToPrincipalId = userId
                });

                Assert.NotNull(allRoleAssignments);
                Assert.NotNull(allRoleAssignments.RoleAssignments);
                Assert.True(allRoleAssignments.RoleAssignments.Count >= 2);

                foreach (var assignment in allRoleAssignments.RoleAssignments)
                {
                    Assert.NotNull(assignment);
                    Assert.NotNull(assignment.Id);
                    Assert.NotNull(assignment.Name);
                    Assert.NotNull(assignment.Type);
                    Assert.NotNull(assignment.Properties);
                    Assert.NotNull(assignment.Properties.PrincipalId);
                    Assert.NotNull(assignment.Properties.RoleDefinitionId);
                    Assert.NotNull(assignment.Properties.Scope);
                }

                // Returned assignments contain assignment to group
                Assert.True(allRoleAssignments.RoleAssignments.Count(a => a.Properties.PrincipalId.ToString() == groupId) >= 1);
            }
        }

        [Fact]
        public void RoleDefinitionsListGetTests()
        {
            using (UndoContext context = UndoContext.Current)
            {
                context.Start();
                var client = testContext.GetAuthorizationManagementClient();

                Assert.NotNull(client);
                Assert.NotNull(client.HttpClient);

                var allRoleDefinitions = client.RoleDefinitions.List();

                Assert.NotNull(allRoleDefinitions);
                Assert.NotNull(allRoleDefinitions.RoleDefinitions);

                foreach (var roleDefinition in allRoleDefinitions.RoleDefinitions)
                {
                    var singleRole = client.RoleDefinitions.Get(roleDefinition.Name);

                    Assert.NotNull(singleRole);

                    if (singleRole.RoleDefinition.Properties.Type == "BuiltInRole")
                    {
                        Assert.NotNull(singleRole.StatusCode);
                        Assert.NotNull(singleRole.RoleDefinition);
                        Assert.NotNull(singleRole.RoleDefinition.Id);
                        Assert.NotNull(singleRole.RoleDefinition.Name);
                        Assert.NotNull(singleRole.RoleDefinition.Type);
                        Assert.NotNull(singleRole.RoleDefinition.Properties);
                        Assert.NotNull(singleRole.RoleDefinition.Properties.Description);
                        Assert.NotNull(singleRole.RoleDefinition.Properties.RoleName);
                        Assert.NotNull(singleRole.RoleDefinition.Properties.Type);
                        Assert.NotNull(singleRole.RoleDefinition.Properties.Permissions);

                        foreach(var assignableScope in singleRole.RoleDefinition.Properties.AssignableScopes)
                        {
                            Assert.True(!string.IsNullOrWhiteSpace(assignableScope));
                        }

                        foreach(var permission in singleRole.RoleDefinition.Properties.Permissions)
                        {
                            Assert.NotNull(permission.Actions);
                            Assert.NotNull(permission.NotActions);
                            Assert.False(permission.Actions.Count() == 0 &&
                            permission.NotActions.Count() == 0);
                        }
                    }
                }
            }
        }

        [Fact]
        public void RoleDefinitionsListWithFilterTests()
        {
            using (UndoContext context = UndoContext.Current)
            {
                context.Start();
                var client = testContext.GetAuthorizationManagementClient();

                Assert.NotNull(client);
                Assert.NotNull(client.HttpClient);

                var ownerRoleDefinition = client.RoleDefinitions.ListWithFilters(
                    new ListDefinitionFilterParameters
                    {
                        RoleName = "Owner"
                    });

                Assert.NotNull(ownerRoleDefinition);
                Assert.NotNull(ownerRoleDefinition.RoleDefinitions);
                Assert.Equal(1, ownerRoleDefinition.RoleDefinitions.Count);

                // Passsing name as null
                var allRoleDefinition = client.RoleDefinitions.ListWithFilters(
                    new ListDefinitionFilterParameters
                    {
                        RoleName = null
                    });

                var allRoleDefinitionsByList = client.RoleDefinitions.List();

                Assert.NotNull(allRoleDefinition);
                Assert.NotNull(allRoleDefinition.RoleDefinitions);
                Assert.Equal(allRoleDefinitionsByList.RoleDefinitions.Count, allRoleDefinition.RoleDefinitions.Count);

                Assert.Throws<ArgumentNullException>(() => client.RoleDefinitions.ListWithFilters(null));
            }
        }

        [Fact]
        public void RoleDefinitionsByIdTests()
        {
            using (UndoContext context = UndoContext.Current)
            {
                context.Start();
                var client = testContext.GetAuthorizationManagementClient();

                Assert.NotNull(client);
                Assert.NotNull(client.HttpClient);

                var allRoleDefinitions = client.RoleDefinitions.List();

                Assert.NotNull(allRoleDefinitions);
                Assert.NotNull(allRoleDefinitions.RoleDefinitions);

                foreach (var roleDefinition in allRoleDefinitions.RoleDefinitions)
                {
                    var singleRole = client.RoleDefinitions.Get(roleDefinition.Name);
                    var byIdRole = client.RoleDefinitions.GetById(roleDefinition.Id);

                    Assert.NotNull(byIdRole);
                    Assert.NotNull(byIdRole.StatusCode);
                    Assert.NotNull(byIdRole.RoleDefinition);
                    Assert.NotNull(byIdRole.RoleDefinition.Id);
                    Assert.NotNull(byIdRole.RoleDefinition.Name);

                    Assert.Equal(
                        singleRole.RoleDefinition.Id,
                        byIdRole.RoleDefinition.Id);
                    Assert.Equal(
                        singleRole.RoleDefinition.Name,
                        byIdRole.RoleDefinition.Name);
                }
            }
        }

        [Fact]
        public void RoleDefinitionUpdateTests()
        {
            using (UndoContext context = UndoContext.Current)
            {
                context.Start();
                var client = testContext.GetAuthorizationManagementClient();

                RoleDefinitionCreateOrUpdateParameters createOrUpdateParams;
                var roleDefinitionId = GetValueFromTestContext(Guid.NewGuid, Guid.Parse, "RoleDefinition");
                string currentSubscriptionId = "/subscriptions/" + client.Credentials.SubscriptionId;

                // Create a custom role definition
                try
                {
                    createOrUpdateParams = new RoleDefinitionCreateOrUpdateParameters()
                    {
                        RoleDefinition = new RoleDefinition()
                        {
                            // Name = roleDefinitionId,
                            Properties = new RoleDefinitionProperties()
                            {
                                RoleName = "NewRoleName_" + roleDefinitionId.ToString(),
                                Description = "New Test Custom Role",
                                Permissions = new List<Permission>()
                                {
                                    new Permission()
                                    {
                                        Actions = new List<string>{ "Microsoft.Authorization/*/Read" }
                                    }
                                },
                                AssignableScopes = new List<string>() { currentSubscriptionId },
                            },
                        }
                    };

                    var roleDefinition = client.RoleDefinitions.CreateOrUpdate(roleDefinitionId, currentSubscriptionId, createOrUpdateParams);

                    // Update role name, permissions for the custom role
                    createOrUpdateParams.RoleDefinition.Properties.RoleName = "UpdatedRoleName_" + roleDefinitionId.ToString();
                    createOrUpdateParams.RoleDefinition.Properties.Permissions.Single().Actions.Add("Microsoft.Support/*/read");

                    var updatedRoleDefinition = client.RoleDefinitions.CreateOrUpdate(roleDefinitionId, currentSubscriptionId, createOrUpdateParams);

                    // Validate the updated roleDefinition properties.
                    Assert.NotNull(updatedRoleDefinition);
                    Assert.NotNull(updatedRoleDefinition.RoleDefinition);
                    Assert.Equal(updatedRoleDefinition.RoleDefinition.Id, roleDefinition.RoleDefinition.Id);
                    Assert.Equal(updatedRoleDefinition.RoleDefinition.Name, roleDefinition.RoleDefinition.Name);
                    // Role name and permissions should be updated
                    Assert.Equal("UpdatedRoleName_" + roleDefinitionId.ToString(), updatedRoleDefinition.RoleDefinition.Properties.RoleName);
                    Assert.NotEmpty(updatedRoleDefinition.RoleDefinition.Properties.Permissions);
                    Assert.Equal("Microsoft.Authorization/*/Read", updatedRoleDefinition.RoleDefinition.Properties.Permissions.Single().Actions.First());
                    Assert.Equal("Microsoft.Support/*/read", updatedRoleDefinition.RoleDefinition.Properties.Permissions.Single().Actions.Last());
                    // Same assignable scopes
                    Assert.NotEmpty(updatedRoleDefinition.RoleDefinition.Properties.AssignableScopes);
                    Assert.Equal(currentSubscriptionId.ToLower(), updatedRoleDefinition.RoleDefinition.Properties.AssignableScopes.Single().ToLower());

                    // Negative test: Update the role with an empty RoleName
                    createOrUpdateParams.RoleDefinition.Properties.RoleName = null;

                    try
                    {
                        client.RoleDefinitions.CreateOrUpdate(roleDefinitionId, currentSubscriptionId, createOrUpdateParams);
                    }
                    catch (CloudException ce)
                    {
                        Assert.Equal("RoleDefinitionNameNullOrEmpty", ce.Error.Code);
                        Assert.Equal(HttpStatusCode.BadRequest, ce.Response.StatusCode);
                    }
                }
                finally
                {
                    var deleteResult = client.RoleDefinitions.Delete(roleDefinitionId, currentSubscriptionId);
                    Assert.NotNull(deleteResult);
                }

                TestUtilities.EndTest();
            }
        }

        [Fact]
        public void RoleDefinitionCreateTests()
        {
            const string RoleDefIdPrefix = "/providers/Microsoft.Authorization/roleDefinitions/";
            using (UndoContext context = UndoContext.Current)
            {
                context.Start();
                var client = testContext.GetAuthorizationManagementClient();

                RoleDefinitionCreateOrUpdateParameters createOrUpdateParams;
                var roleDefinitionId = GetValueFromTestContext(Guid.NewGuid, Guid.Parse, "RoleDefinition1");
                string currentSubscriptionId = "/subscriptions/" + client.Credentials.SubscriptionId;
                string fullRoleId = currentSubscriptionId + RoleDefIdPrefix + roleDefinitionId;

                Guid newRoleId = GetValueFromTestContext(Guid.NewGuid, Guid.Parse, "RoleDefinition2");
                var resourceGroup = "newtestrg";
                string resourceGroupScope = currentSubscriptionId + "/resourceGroups/" + resourceGroup;

                // Create a custom role definition
                try
                {
                    createOrUpdateParams = new RoleDefinitionCreateOrUpdateParameters()
                    {
                        RoleDefinition = new RoleDefinition()
                        {
                            Properties = new RoleDefinitionProperties()
                            {
                                RoleName = "NewRoleName_" + roleDefinitionId.ToString(),
                                Description = "New Test Custom Role",
                                Permissions = new List<Permission>()
                                {
                                    new Permission()
                                    {
                                        Actions = new List<string>{ "Microsoft.Authorization/*/Read" }
                                    }
                                },
                                AssignableScopes = new List<string>() { currentSubscriptionId },
                            },
                        }
                    };

                    var roleDefinition = client.RoleDefinitions.CreateOrUpdate(roleDefinitionId, currentSubscriptionId, createOrUpdateParams);

                    // Validate the roleDefinition properties.
                    Assert.NotNull(roleDefinition);
                    Assert.NotNull(roleDefinition.RoleDefinition);
                    Assert.Equal(fullRoleId, roleDefinition.RoleDefinition.Id);
                    Assert.Equal(roleDefinitionId, roleDefinition.RoleDefinition.Name);
                    Assert.NotNull(roleDefinition.RoleDefinition.Properties);
                    Assert.Equal("CustomRole", roleDefinition.RoleDefinition.Properties.Type);
                    Assert.Equal("New Test Custom Role", roleDefinition.RoleDefinition.Properties.Description);
                    Assert.NotEmpty(roleDefinition.RoleDefinition.Properties.AssignableScopes);
                    Assert.Equal(currentSubscriptionId.ToLower(), roleDefinition.RoleDefinition.Properties.AssignableScopes.Single().ToLower());
                    Assert.NotEmpty(roleDefinition.RoleDefinition.Properties.Permissions);
                    Assert.Equal("Microsoft.Authorization/*/Read", roleDefinition.RoleDefinition.Properties.Permissions.Single().Actions.Single());

                    // create resource group
                    var resourceClient = PermissionsTests.GetResourceManagementClient();
                    resourceClient.ResourceGroups.CreateOrUpdate(resourceGroup, new Microsoft.Azure.Management.Resources.Models.ResourceGroup { Location = "westus"});
                    createOrUpdateParams.RoleDefinition.Properties.AssignableScopes = new List<string> { resourceGroupScope };
                    createOrUpdateParams.RoleDefinition.Properties.RoleName = "NewRoleName_" + newRoleId.ToString();

                    roleDefinition = client.RoleDefinitions.CreateOrUpdate(newRoleId, resourceGroupScope, createOrUpdateParams);
                    Assert.NotNull(roleDefinition);

                }
                finally
                {
                    var deleteResult = client.RoleDefinitions.Delete(roleDefinitionId, currentSubscriptionId);
                    Assert.NotNull(deleteResult);

                    deleteResult = client.RoleDefinitions.Delete(newRoleId, resourceGroupScope);
                    Assert.NotNull(deleteResult);
                }

                TestUtilities.Wait(1000 * 15);

                // Negative test - create a roledefinition with same name (but different id) as an already existing custom role
                try
                {
                    client.RoleDefinitions.CreateOrUpdate(roleDefinitionId, currentSubscriptionId, createOrUpdateParams);
                    var roleDefinition2Id = GetValueFromTestContext(Guid.NewGuid, Guid.Parse, "RoleDefinition3");
                    client.RoleDefinitions.CreateOrUpdate(roleDefinition2Id, currentSubscriptionId, createOrUpdateParams);
                }
                catch (CloudException ce)
                {
                    Assert.Equal("RoleDefinitionWithSameNameExists", ce.Error.Code);
                    Assert.Equal(HttpStatusCode.Conflict, ce.Response.StatusCode);
                }
                finally
                {
                    var deleteResult = client.RoleDefinitions.Delete(roleDefinitionId, currentSubscriptionId);
                    Assert.NotNull(deleteResult);
                }

                // Negative test - create a roledefinition with same id as a built-in role
                try
                {
                    var allRoleDefinitions = client.RoleDefinitions.List();
                    Assert.NotNull(allRoleDefinitions);
                    Assert.NotNull(allRoleDefinitions.RoleDefinitions);
                    RoleDefinition builtInRole = allRoleDefinitions.RoleDefinitions.First(x => x.Properties.Type == "BuiltInRole");

                    createOrUpdateParams.RoleDefinition.Properties.RoleName = "NewRoleName_" + builtInRole.Name.ToString();
                    client.RoleDefinitions.CreateOrUpdate(builtInRole.Name, currentSubscriptionId, createOrUpdateParams);
                }
                catch (CloudException ce)
                {
                    Assert.Equal("RoleDefinitionExists", ce.Error.Code);
                    Assert.Equal(HttpStatusCode.Conflict, ce.Response.StatusCode);
                }

                // Negative test - create a roledefinition with type=BuiltInRole
                createOrUpdateParams.RoleDefinition.Properties.Type = "BuiltInRole";

                try
                {
                    client.RoleDefinitions.CreateOrUpdate(roleDefinitionId, currentSubscriptionId, createOrUpdateParams);
                }
                catch(CloudException ce)
                {
                    Assert.Equal("InvalidRoleDefinitionType", ce.Error.Code);
                    Assert.Equal(HttpStatusCode.BadRequest, ce.Response.StatusCode);
                }

                // Negative Test - create a custom role with empty role name
                // reset the role type
                createOrUpdateParams.RoleDefinition.Properties.Type = null;
                createOrUpdateParams.RoleDefinition.Properties.RoleName = string.Empty;

                try
                {
                    client.RoleDefinitions.CreateOrUpdate(roleDefinitionId, currentSubscriptionId, createOrUpdateParams);
                }
                catch (CloudException ce)
                {
                    Assert.Equal("RoleDefinitionNameNullOrEmpty", ce.Error.Code);
                    Assert.Equal(HttpStatusCode.BadRequest, ce.Response.StatusCode);
                }

                // Negative Test - create a custom role with empty assignable scopes
                // reset the role name
                createOrUpdateParams.RoleDefinition.Properties.RoleName = "NewRoleName_" + roleDefinitionId.ToString();
                createOrUpdateParams.RoleDefinition.Properties.AssignableScopes = new List<string>();

                try
                {
                    client.RoleDefinitions.CreateOrUpdate(roleDefinitionId, currentSubscriptionId, createOrUpdateParams);
                }
                catch (CloudException ce)
                {
                    Assert.Equal("MissingAssignableScopes", ce.Error.Code);
                    Assert.Equal(HttpStatusCode.BadRequest, ce.Response.StatusCode);
                }

                // Negative Test - create a custom role with invalid value for assignable scopes
                createOrUpdateParams.RoleDefinition.Properties.AssignableScopes.Add("Invalid_Scope");

                try
                {
                    client.RoleDefinitions.CreateOrUpdate(roleDefinitionId, currentSubscriptionId, createOrUpdateParams);
                }
                catch (CloudException ce)
                {
                    Assert.Equal("LinkedInvalidPropertyId", ce.Error.Code);
                    Assert.Equal(HttpStatusCode.BadRequest, ce.Response.StatusCode);
                }

                // Negative Test - create a custom role with empty permissions
                // reset assignable scopes

                /* TODO: Uncomment the below test case when PAS/PAS-RP determine whether to implement blocking of
                 * create with empty Permission list
                 */
                ////createOrUpdateParams.RoleDefinition.Properties.AssignableScopes.Remove("Invalid_Scope");
                ////createOrUpdateParams.RoleDefinition.Properties.AssignableScopes.Add(currentSubscriptionId);
                ////createOrUpdateParams.RoleDefinition.Properties.Permissions = new List<Permission>();

                ////try
                ////{
                ////    client.RoleDefinitions.CreateOrUpdate(roleDefinitionId, createOrUpdateParams);
                ////}
                ////catch (CloudException ce)
                ////{
                ////    Assert.Equal("AssignableScopeNotUnderSubscriptionScope", ce.Error.Code);
                ////    Assert.Equal(HttpStatusCode.BadRequest, ce.Response.StatusCode);
                ////}

                TestUtilities.EndTest();
            }
        }

        private static T GetValueFromTestContext<T>(Func<T> constructor, Func<string, T> parser, string mockName)
        {
            T retValue = default(T);

            if (HttpMockServer.Mode == HttpRecorderMode.Record)
            {
                retValue = constructor.Invoke();
                HttpMockServer.Variables[mockName] = retValue.ToString();
            }
            else
            {
                if (HttpMockServer.Variables.ContainsKey(mockName))
                {
                    retValue = parser.Invoke(HttpMockServer.Variables[mockName]);
                }
            }

            return retValue;
        }
    }
}


text:
#ifndef FLUX_BINARYNODE_H
#define FLUX_BINARYNODE_H

namespace flux {

class BinaryNode
{
public:
    BinaryNode()
        : weight_(1),
          balance_(0)
    {}
    BinaryNode(const BinaryNode &kb)
        : weight_(kb.weight_),
          balance_(kb.balance_)
    {}

    BinaryNode *left_;
    BinaryNode *right_;
    BinaryNode *parent_;
    int weight_;
    int balance_;
};

} // namespace flux

#endif // FLUX_BINARYNODE_H


text:
SYNONYM

#### According to
GRIN Taxonomy for Plants

#### Published in
Gard. Chron. ser. 3, 3:9. 1888 "<I>canoni</I>"

#### Original name
null

### Remarks
null


text:
package types

import "fmt"

type (
	MinutiaeType byte
	MinutiaeList []Minutiae
)

const (
	Termination MinutiaeType = iota
	Bifurcation
	Pore
	Unknown
)

type Minutiae struct {
	X     int          `json:"x"`
	Y     int          `json:"y"`
	Angle float64      `json:"angle"`
	Type  MinutiaeType `json:"type"`
}

func (m Minutiae) String() string {
	return fmt.Sprintf("[%d,%d] Type=%v, Angle=%f", m.X, m.Y, m.Type, m.Angle)
}

func (t MinutiaeType) String() string {
	switch t {
	case Termination:
		return "t"
	case Bifurcation:
		return "b"
	default:
		return "n/a"
	}
}


text:
/*
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.osgi.security.dos0332.test;

import static org.junit.Assert.fail;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.osgi.security.test.api.OSGiSecurityTestRunner;

@RunWith(OSGiSecurityTestRunner.class)
public class Dos0332Test {

    @Test
    public void testDos0332() throws Exception {

    	try {
            Thread t = new Thread(new RecursiveThread(0));
            t.start();
        } catch (Exception e) {
        	System.out.println(e.getMessage());
        }

    	Thread.sleep(30000);

    	fail("[FAIL] Threads can use system resources without limits.");
    }
}


text:
namespace Microsoft.Azure.Management.VideoAnalyzer.Models
{
    using Newtonsoft.Json;

    /// <summary>
    /// Defines values for AccountEncryptionKeyType.
    /// </summary>
    /// <summary>
    /// Determine base value for a given allowed value if exists, else return
    /// the value itself
    /// </summary>
    [JsonConverter(typeof(AccountEncryptionKeyTypeConverter))]
    public struct AccountEncryptionKeyType : System.IEquatable<AccountEncryptionKeyType>
    {
        private AccountEncryptionKeyType(string underlyingValue)
        {
            UnderlyingValue=underlyingValue;
        }

        /// <summary>
        /// The Account Key is encrypted with a System Key.
        /// </summary>
        public static readonly AccountEncryptionKeyType SystemKey = "SystemKey";

        /// <summary>
        /// The Account Key is encrypted with a Customer Key.
        /// </summary>
        public static readonly AccountEncryptionKeyType CustomerKey = "CustomerKey";

        /// <summary>
        /// Underlying value of enum AccountEncryptionKeyType
        /// </summary>
        private readonly string UnderlyingValue;

        /// <summary>
        /// Returns string representation for AccountEncryptionKeyType
        /// </summary>
        public override string ToString()
        {
            return UnderlyingValue == null ? null : UnderlyingValue.ToString();
        }

        /// <summary>
        /// Compares enums of type AccountEncryptionKeyType
        /// </summary>
        public bool Equals(AccountEncryptionKeyType e)
        {
            return UnderlyingValue.Equals(e.UnderlyingValue);
        }

        /// <summary>
        /// Implicit operator to convert string to AccountEncryptionKeyType
        /// </summary>
        public static implicit operator AccountEncryptionKeyType(string value)
        {
            return new AccountEncryptionKeyType(value);
        }

        /// <summary>
        /// Implicit operator to convert AccountEncryptionKeyType to string
        /// </summary>
        public static implicit operator string(AccountEncryptionKeyType e)
        {
            return e.UnderlyingValue;
        }

        /// <summary>
        /// Overriding == operator for enum AccountEncryptionKeyType
        /// </summary>
        public static bool operator == (AccountEncryptionKeyType e1, AccountEncryptionKeyType e2)
        {
            return e2.Equals(e1);
        }

        /// <summary>
        /// Overriding != operator for enum AccountEncryptionKeyType
        /// </summary>
        public static bool operator != (AccountEncryptionKeyType e1, AccountEncryptionKeyType e2)
        {
            return !e2.Equals(e1);
        }

        /// <summary>
        /// Overrides Equals operator for AccountEncryptionKeyType
        /// </summary>
        public override bool Equals(object obj)
        {
            return obj is AccountEncryptionKeyType && Equals((AccountEncryptionKeyType)obj);
        }

        /// <summary>
        /// Returns for hashCode AccountEncryptionKeyType
        /// </summary>
        public override int GetHashCode()
        {
            return UnderlyingValue.GetHashCode();
        }

    }
}