Changeset 3939


Ignore:
Timestamp:
06/23/10 00:23:20 (9 years ago)
Author:
hmayr
Message:

first commit from hmayr, just minor changes (#1046)

  • formatted source code files to fit HeuristicLab standards
  • deleted old LINQ to SQL Classes
  • create LINQ to SQL Class for HeuristicLabUser (just prototype)
Location:
branches/HeuristicLab.Services.Authentication Prototype
Files:
3 added
7 edited

Legend:

Unmodified
Added
Removed
  • branches/HeuristicLab.Services.Authentication Prototype/Persistence/Persistence.csproj

    r3932 r3939  
    5050  </ItemGroup>
    5151  <ItemGroup>
    52     <Compile Include="HeuristicLabUser.cs">
    53       <DependentUpon>HeuristicLabUser.dbml</DependentUpon>
     52    <Compile Include="DataClasses.cs">
     53      <DependentUpon>DataClasses.dbml</DependentUpon>
    5454    </Compile>
    5555    <Compile Include="HeuristicLabUser.designer.cs">
     
    7272  <ItemGroup>
    7373    <None Include="ClassDiagram1.cd" />
     74    <None Include="DataClasses.dbml">
     75      <Generator>MSLinqToSQLGenerator</Generator>
     76      <SubType>Designer</SubType>
     77    </None>
    7478    <None Include="HeuristicLabUser.dbml.layout">
    7579      <DependentUpon>HeuristicLabUser.dbml</DependentUpon>
     80    </None>
     81  </ItemGroup>
     82  <ItemGroup>
     83    <None Include="DataClasses.dbml.layout">
     84      <DependentUpon>DataClasses.dbml</DependentUpon>
    7685    </None>
    7786  </ItemGroup>
  • branches/HeuristicLab.Services.Authentication Prototype/Service/IService1.cs

    r3932 r3939  
    66using System.Text;
    77
    8 namespace Service
    9 {
    10     // HINWEIS: Wenn Sie hier den Schnittstellennamen "IService1" ändern, müssen Sie ebenfalls den Verweis auf "IService1" in "App.config" aktualisieren.
    11     [ServiceContract]
    12     public interface IService1
    13     {
    14         [OperationContract]
    15         string GetData(int value);
     8namespace Service {
     9  // HINWEIS: Wenn Sie hier den Schnittstellennamen "IService1" ändern, müssen Sie ebenfalls den Verweis auf "IService1" in "App.config" aktualisieren.
     10  [ServiceContract]
     11  public interface IService1 {
     12    [OperationContract]
     13    string GetData(int value);
    1614
    17         [OperationContract]
    18         CompositeType GetDataUsingDataContract(CompositeType composite);
     15    [OperationContract]
     16    CompositeType GetDataUsingDataContract(CompositeType composite);
    1917
    20         // AUFGABE: Hier Dienstvorgänge hinzufügen
     18    // AUFGABE: Hier Dienstvorgänge hinzufügen
     19  }
     20
     21  // Verwenden Sie einen Datenvertrag, wie im folgenden Beispiel dargestellt, um Dienstvorgängen zusammengesetzte Typen hinzuzufügen.
     22  [DataContract]
     23  public class CompositeType {
     24    bool boolValue = true;
     25    string stringValue = "Hello ";
     26
     27    [DataMember]
     28    public bool BoolValue {
     29      get { return boolValue; }
     30      set { boolValue = value; }
    2131    }
    2232
    23     // Verwenden Sie einen Datenvertrag, wie im folgenden Beispiel dargestellt, um Dienstvorgängen zusammengesetzte Typen hinzuzufügen.
    24     [DataContract]
    25     public class CompositeType
    26     {
    27         bool boolValue = true;
    28         string stringValue = "Hello ";
    29 
    30         [DataMember]
    31         public bool BoolValue
    32         {
    33             get { return boolValue; }
    34             set { boolValue = value; }
    35         }
    36 
    37         [DataMember]
    38         public string StringValue
    39         {
    40             get { return stringValue; }
    41             set { stringValue = value; }
    42         }
     33    [DataMember]
     34    public string StringValue {
     35      get { return stringValue; }
     36      set { stringValue = value; }
    4337    }
     38  }
    4439}
  • branches/HeuristicLab.Services.Authentication Prototype/Service/Provider/HeuristicLabMembershipProvider.cs

    r3932 r3939  
    55using System.Web.Security;
    66
    7 namespace Service.Provider
    8 {
    9     class HeuristicLabMembershipProvider : MembershipProvider
    10     {
    11         public override string ApplicationName
    12         {
    13             get
    14             {
    15                 throw new NotImplementedException();
    16             }
    17             set
    18             {
    19                 throw new NotImplementedException();
    20             }
    21         }
     7namespace Service.Provider {
     8  class HeuristicLabMembershipProvider : MembershipProvider {
     9    public override string ApplicationName {
     10      get {
     11        throw new NotImplementedException();
     12      }
     13      set {
     14        throw new NotImplementedException();
     15      }
     16    }
    2217
    23         public override bool ChangePassword(string username, string oldPassword, string newPassword)
    24         {
    25             throw new NotImplementedException();
    26         }
     18    public override bool ChangePassword(string username, string oldPassword, string newPassword) {
     19      throw new NotImplementedException();
     20    }
    2721
    28         public override bool ChangePasswordQuestionAndAnswer(string username, string password, string newPasswordQuestion, string newPasswordAnswer)
    29         {
    30             throw new NotImplementedException();
    31         }
     22    public override bool ChangePasswordQuestionAndAnswer(string username, string password, string newPasswordQuestion, string newPasswordAnswer) {
     23      throw new NotImplementedException();
     24    }
    3225
    33         public override MembershipUser CreateUser(string username, string password, string email, string passwordQuestion, string passwordAnswer, bool isApproved, object providerUserKey, out MembershipCreateStatus status)
    34         {
    35             throw new NotImplementedException();
    36         }
     26    public override MembershipUser CreateUser(string username, string password, string email, string passwordQuestion, string passwordAnswer, bool isApproved, object providerUserKey, out MembershipCreateStatus status) {
     27      throw new NotImplementedException();
     28    }
    3729
    38         public override bool DeleteUser(string username, bool deleteAllRelatedData)
    39         {
    40             throw new NotImplementedException();
    41         }
     30    public override bool DeleteUser(string username, bool deleteAllRelatedData) {
     31      throw new NotImplementedException();
     32    }
    4233
    43         public override bool EnablePasswordReset
    44         {
    45             get { throw new NotImplementedException(); }
    46         }
     34    public override bool EnablePasswordReset {
     35      get { throw new NotImplementedException(); }
     36    }
    4737
    48         public override bool EnablePasswordRetrieval
    49         {
    50             get { throw new NotImplementedException(); }
    51         }
     38    public override bool EnablePasswordRetrieval {
     39      get { throw new NotImplementedException(); }
     40    }
    5241
    53         public override MembershipUserCollection FindUsersByEmail(string emailToMatch, int pageIndex, int pageSize, out int totalRecords)
    54         {
    55             throw new NotImplementedException();
    56         }
     42    public override MembershipUserCollection FindUsersByEmail(string emailToMatch, int pageIndex, int pageSize, out int totalRecords) {
     43      throw new NotImplementedException();
     44    }
    5745
    58         public override MembershipUserCollection FindUsersByName(string usernameToMatch, int pageIndex, int pageSize, out int totalRecords)
    59         {
    60             throw new NotImplementedException();
    61         }
     46    public override MembershipUserCollection FindUsersByName(string usernameToMatch, int pageIndex, int pageSize, out int totalRecords) {
     47      throw new NotImplementedException();
     48    }
    6249
    63         public override MembershipUserCollection GetAllUsers(int pageIndex, int pageSize, out int totalRecords)
    64         {
    65             throw new NotImplementedException();
    66         }
     50    public override MembershipUserCollection GetAllUsers(int pageIndex, int pageSize, out int totalRecords) {
     51      throw new NotImplementedException();
     52    }
    6753
    68         public override int GetNumberOfUsersOnline()
    69         {
    70             throw new NotImplementedException();
    71         }
     54    public override int GetNumberOfUsersOnline() {
     55      throw new NotImplementedException();
     56    }
    7257
    73         public override string GetPassword(string username, string answer)
    74         {
    75             throw new NotImplementedException();
    76         }
     58    public override string GetPassword(string username, string answer) {
     59      throw new NotImplementedException();
     60    }
    7761
    78         public override MembershipUser GetUser(string username, bool userIsOnline)
    79         {
    80             throw new NotImplementedException();
    81         }
     62    public override MembershipUser GetUser(string username, bool userIsOnline) {
     63      throw new NotImplementedException();
     64    }
    8265
    83         public override MembershipUser GetUser(object providerUserKey, bool userIsOnline)
    84         {
    85             throw new NotImplementedException();
    86         }
     66    public override MembershipUser GetUser(object providerUserKey, bool userIsOnline) {
     67      throw new NotImplementedException();
     68    }
    8769
    88         public override string GetUserNameByEmail(string email)
    89         {
    90             throw new NotImplementedException();
    91         }
     70    public override string GetUserNameByEmail(string email) {
     71      throw new NotImplementedException();
     72    }
    9273
    93         public override int MaxInvalidPasswordAttempts
    94         {
    95             get { throw new NotImplementedException(); }
    96         }
     74    public override int MaxInvalidPasswordAttempts {
     75      get { throw new NotImplementedException(); }
     76    }
    9777
    98         public override int MinRequiredNonAlphanumericCharacters
    99         {
    100             get { throw new NotImplementedException(); }
    101         }
     78    public override int MinRequiredNonAlphanumericCharacters {
     79      get { throw new NotImplementedException(); }
     80    }
    10281
    103         public override int MinRequiredPasswordLength
    104         {
    105             get { throw new NotImplementedException(); }
    106         }
     82    public override int MinRequiredPasswordLength {
     83      get { throw new NotImplementedException(); }
     84    }
    10785
    108         public override int PasswordAttemptWindow
    109         {
    110             get { throw new NotImplementedException(); }
    111         }
     86    public override int PasswordAttemptWindow {
     87      get { throw new NotImplementedException(); }
     88    }
    11289
    113         public override MembershipPasswordFormat PasswordFormat
    114         {
    115             get { throw new NotImplementedException(); }
    116         }
     90    public override MembershipPasswordFormat PasswordFormat {
     91      get { throw new NotImplementedException(); }
     92    }
    11793
    118         public override string PasswordStrengthRegularExpression
    119         {
    120             get { throw new NotImplementedException(); }
    121         }
     94    public override string PasswordStrengthRegularExpression {
     95      get { throw new NotImplementedException(); }
     96    }
    12297
    123         public override bool RequiresQuestionAndAnswer
    124         {
    125             get { throw new NotImplementedException(); }
    126         }
     98    public override bool RequiresQuestionAndAnswer {
     99      get { throw new NotImplementedException(); }
     100    }
    127101
    128         public override bool RequiresUniqueEmail
    129         {
    130             get { throw new NotImplementedException(); }
    131         }
     102    public override bool RequiresUniqueEmail {
     103      get { throw new NotImplementedException(); }
     104    }
    132105
    133         public override string ResetPassword(string username, string answer)
    134         {
    135             throw new NotImplementedException();
    136         }
     106    public override string ResetPassword(string username, string answer) {
     107      throw new NotImplementedException();
     108    }
    137109
    138         public override bool UnlockUser(string userName)
    139         {
    140             throw new NotImplementedException();
    141         }
     110    public override bool UnlockUser(string userName) {
     111      throw new NotImplementedException();
     112    }
    142113
    143         public override void UpdateUser(MembershipUser user)
    144         {
    145             throw new NotImplementedException();
    146         }
     114    public override void UpdateUser(MembershipUser user) {
     115      throw new NotImplementedException();
     116    }
    147117
    148         public override bool ValidateUser(string username, string password)
    149         {
    150             throw new NotImplementedException();
    151         }
     118    public override bool ValidateUser(string username, string password) {
     119      throw new NotImplementedException();
    152120    }
     121  }
    153122}
  • branches/HeuristicLab.Services.Authentication Prototype/Service/Provider/HeuristicLabRoleProvider.cs

    r3932 r3939  
    55using System.Web.Security;
    66
    7 namespace Service.Provider
    8 {
    9     class HeuristicLabRoleProvider : RoleProvider
    10     {
    11         public override void AddUsersToRoles(string[] usernames, string[] roleNames)
    12         {
    13             throw new NotImplementedException();
    14         }
     7namespace Service.Provider {
     8  class HeuristicLabRoleProvider : RoleProvider {
     9    public override void AddUsersToRoles(string[] usernames, string[] roleNames) {
     10      throw new NotImplementedException();
     11    }
    1512
    16         public override string ApplicationName
    17         {
    18             get
    19             {
    20                 throw new NotImplementedException();
    21             }
    22             set
    23             {
    24                 throw new NotImplementedException();
    25             }
    26         }
     13    public override string ApplicationName {
     14      get {
     15        throw new NotImplementedException();
     16      }
     17      set {
     18        throw new NotImplementedException();
     19      }
     20    }
    2721
    28         public override void CreateRole(string roleName)
    29         {
    30             throw new NotImplementedException();
    31         }
     22    public override void CreateRole(string roleName) {
     23      throw new NotImplementedException();
     24    }
    3225
    33         public override bool DeleteRole(string roleName, bool throwOnPopulatedRole)
    34         {
    35             throw new NotImplementedException();
    36         }
     26    public override bool DeleteRole(string roleName, bool throwOnPopulatedRole) {
     27      throw new NotImplementedException();
     28    }
    3729
    38         public override string[] FindUsersInRole(string roleName, string usernameToMatch)
    39         {
    40             throw new NotImplementedException();
    41         }
     30    public override string[] FindUsersInRole(string roleName, string usernameToMatch) {
     31      throw new NotImplementedException();
     32    }
    4233
    43         public override string[] GetAllRoles()
    44         {
    45             throw new NotImplementedException();
    46         }
     34    public override string[] GetAllRoles() {
     35      throw new NotImplementedException();
     36    }
    4737
    48         public override string[] GetRolesForUser(string username)
    49         {
    50             throw new NotImplementedException();
    51         }
     38    public override string[] GetRolesForUser(string username) {
     39      throw new NotImplementedException();
     40    }
    5241
    53         public override string[] GetUsersInRole(string roleName)
    54         {
    55             throw new NotImplementedException();
    56         }
     42    public override string[] GetUsersInRole(string roleName) {
     43      throw new NotImplementedException();
     44    }
    5745
    58         public override bool IsUserInRole(string username, string roleName)
    59         {
    60             throw new NotImplementedException();
    61         }
     46    public override bool IsUserInRole(string username, string roleName) {
     47      throw new NotImplementedException();
     48    }
    6249
    63         public override void RemoveUsersFromRoles(string[] usernames, string[] roleNames)
    64         {
    65             throw new NotImplementedException();
    66         }
     50    public override void RemoveUsersFromRoles(string[] usernames, string[] roleNames) {
     51      throw new NotImplementedException();
     52    }
    6753
    68         public override bool RoleExists(string roleName)
    69         {
    70             throw new NotImplementedException();
    71         }
     54    public override bool RoleExists(string roleName) {
     55      throw new NotImplementedException();
    7256    }
     57  }
    7358}
  • branches/HeuristicLab.Services.Authentication Prototype/Service/Service1.cs

    r3932 r3939  
    66using System.Text;
    77
    8 namespace Service
    9 {
    10     // HINWEIS: Wenn Sie hier den Klassennamen "Service1" ändern, müssen Sie ebenfalls den Verweis auf "Service1" in "App.config" aktualisieren.
    11     public class Service1 : IService1
    12     {
    13         public string GetData(int value)
    14         {
    15             return string.Format("You entered: {0}", value);
    16         }
     8namespace Service {
     9  // HINWEIS: Wenn Sie hier den Klassennamen "Service1" ändern, müssen Sie ebenfalls den Verweis auf "Service1" in "App.config" aktualisieren.
     10  public class Service1 : IService1 {
     11    public string GetData(int value) {
     12      return string.Format("You entered: {0}", value);
     13    }
    1714
    18         public CompositeType GetDataUsingDataContract(CompositeType composite)
    19         {
    20             if (composite.BoolValue)
    21             {
    22                 composite.StringValue += "Suffix";
    23             }
    24             return composite;
    25         }
     15    public CompositeType GetDataUsingDataContract(CompositeType composite) {
     16      if (composite.BoolValue) {
     17        composite.StringValue += "Suffix";
     18      }
     19      return composite;
    2620    }
     21  }
    2722}
  • branches/HeuristicLab.Services.Authentication Prototype/UnitTests/HeuristicLabMembershipProviderTest.cs

    r3932 r3939  
    33using System.Web.Security;
    44
    5 namespace UnitTests
    6 {
    7    
    8    
    9     /// <summary>
    10     ///Dies ist eine Testklasse für "HeuristicLabMembershipProviderTest" und soll
    11     ///alle HeuristicLabMembershipProviderTest Komponententests enthalten.
    12     ///</summary>
    13     [TestClass()]
    14     public class HeuristicLabMembershipProviderTest
    15     {
    16 
    17 
    18         private TestContext testContextInstance;
    19 
    20         /// <summary>
    21         ///Ruft den Testkontext auf, der Informationen
    22         ///über und Funktionalität für den aktuellen Testlauf bietet, oder legt diesen fest.
    23         ///</summary>
    24         public TestContext TestContext
    25         {
    26             get
    27             {
    28                 return testContextInstance;
    29             }
    30             set
    31             {
    32                 testContextInstance = value;
    33             }
    34         }
    35 
    36         #region Zusätzliche Testattribute
    37         //
    38         //Sie können beim Verfassen Ihrer Tests die folgenden zusätzlichen Attribute verwenden:
    39         //
    40         //Mit ClassInitialize führen Sie Code aus, bevor Sie den ersten Test in der Klasse ausführen.
    41         //[ClassInitialize()]
    42         //public static void MyClassInitialize(TestContext testContext)
    43         //{
    44         //}
    45         //
    46         //Mit ClassCleanup führen Sie Code aus, nachdem alle Tests in einer Klasse ausgeführt wurden.
    47         //[ClassCleanup()]
    48         //public static void MyClassCleanup()
    49         //{
    50         //}
    51         //
    52         //Mit TestInitialize können Sie vor jedem einzelnen Test Code ausführen.
    53         //[TestInitialize()]
    54         //public void MyTestInitialize()
    55         //{
    56         //}
    57         //
    58         //Mit TestCleanup können Sie nach jedem einzelnen Test Code ausführen.
    59         //[TestCleanup()]
    60         //public void MyTestCleanup()
    61         //{
    62         //}
    63         //
    64         #endregion
    65 
    66 
    67         /// <summary>
    68         ///Ein Test für "RequiresUniqueEmail"
    69         ///</summary>
    70         [TestMethod()]
    71         public void RequiresUniqueEmailTest()
    72         {
    73             HeuristicLabMembershipProvider target = new HeuristicLabMembershipProvider(); // TODO: Passenden Wert initialisieren
    74             bool actual;
    75             actual = target.RequiresUniqueEmail;
    76             Assert.Inconclusive("Überprüfen Sie die Richtigkeit dieser Testmethode.");
    77         }
    78 
    79         /// <summary>
    80         ///Ein Test für "RequiresQuestionAndAnswer"
    81         ///</summary>
    82         [TestMethod()]
    83         public void RequiresQuestionAndAnswerTest()
    84         {
    85             HeuristicLabMembershipProvider target = new HeuristicLabMembershipProvider(); // TODO: Passenden Wert initialisieren
    86             bool actual;
    87             actual = target.RequiresQuestionAndAnswer;
    88             Assert.Inconclusive("Überprüfen Sie die Richtigkeit dieser Testmethode.");
    89         }
    90 
    91         /// <summary>
    92         ///Ein Test für "PasswordStrengthRegularExpression"
    93         ///</summary>
    94         [TestMethod()]
    95         public void PasswordStrengthRegularExpressionTest()
    96         {
    97             HeuristicLabMembershipProvider target = new HeuristicLabMembershipProvider(); // TODO: Passenden Wert initialisieren
    98             string actual;
    99             actual = target.PasswordStrengthRegularExpression;
    100             Assert.Inconclusive("Überprüfen Sie die Richtigkeit dieser Testmethode.");
    101         }
    102 
    103         /// <summary>
    104         ///Ein Test für "PasswordFormat"
    105         ///</summary>
    106         [TestMethod()]
    107         public void PasswordFormatTest()
    108         {
    109             HeuristicLabMembershipProvider target = new HeuristicLabMembershipProvider(); // TODO: Passenden Wert initialisieren
    110             MembershipPasswordFormat actual;
    111             actual = target.PasswordFormat;
    112             Assert.Inconclusive("Überprüfen Sie die Richtigkeit dieser Testmethode.");
    113         }
    114 
    115         /// <summary>
    116         ///Ein Test für "PasswordAttemptWindow"
    117         ///</summary>
    118         [TestMethod()]
    119         public void PasswordAttemptWindowTest()
    120         {
    121             HeuristicLabMembershipProvider target = new HeuristicLabMembershipProvider(); // TODO: Passenden Wert initialisieren
    122             int actual;
    123             actual = target.PasswordAttemptWindow;
    124             Assert.Inconclusive("Überprüfen Sie die Richtigkeit dieser Testmethode.");
    125         }
    126 
    127         /// <summary>
    128         ///Ein Test für "MinRequiredPasswordLength"
    129         ///</summary>
    130         [TestMethod()]
    131         public void MinRequiredPasswordLengthTest()
    132         {
    133             HeuristicLabMembershipProvider target = new HeuristicLabMembershipProvider(); // TODO: Passenden Wert initialisieren
    134             int actual;
    135             actual = target.MinRequiredPasswordLength;
    136             Assert.Inconclusive("Überprüfen Sie die Richtigkeit dieser Testmethode.");
    137         }
    138 
    139         /// <summary>
    140         ///Ein Test für "MinRequiredNonAlphanumericCharacters"
    141         ///</summary>
    142         [TestMethod()]
    143         public void MinRequiredNonAlphanumericCharactersTest()
    144         {
    145             HeuristicLabMembershipProvider target = new HeuristicLabMembershipProvider(); // TODO: Passenden Wert initialisieren
    146             int actual;
    147             actual = target.MinRequiredNonAlphanumericCharacters;
    148             Assert.Inconclusive("Überprüfen Sie die Richtigkeit dieser Testmethode.");
    149         }
    150 
    151         /// <summary>
    152         ///Ein Test für "MaxInvalidPasswordAttempts"
    153         ///</summary>
    154         [TestMethod()]
    155         public void MaxInvalidPasswordAttemptsTest()
    156         {
    157             HeuristicLabMembershipProvider target = new HeuristicLabMembershipProvider(); // TODO: Passenden Wert initialisieren
    158             int actual;
    159             actual = target.MaxInvalidPasswordAttempts;
    160             Assert.Inconclusive("Überprüfen Sie die Richtigkeit dieser Testmethode.");
    161         }
    162 
    163         /// <summary>
    164         ///Ein Test für "EnablePasswordRetrieval"
    165         ///</summary>
    166         [TestMethod()]
    167         public void EnablePasswordRetrievalTest()
    168         {
    169             HeuristicLabMembershipProvider target = new HeuristicLabMembershipProvider(); // TODO: Passenden Wert initialisieren
    170             bool actual;
    171             actual = target.EnablePasswordRetrieval;
    172             Assert.Inconclusive("Überprüfen Sie die Richtigkeit dieser Testmethode.");
    173         }
    174 
    175         /// <summary>
    176         ///Ein Test für "EnablePasswordReset"
    177         ///</summary>
    178         [TestMethod()]
    179         public void EnablePasswordResetTest()
    180         {
    181             HeuristicLabMembershipProvider target = new HeuristicLabMembershipProvider(); // TODO: Passenden Wert initialisieren
    182             bool actual;
    183             actual = target.EnablePasswordReset;
    184             Assert.Inconclusive("Überprüfen Sie die Richtigkeit dieser Testmethode.");
    185         }
    186 
    187         /// <summary>
    188         ///Ein Test für "ApplicationName"
    189         ///</summary>
    190         [TestMethod()]
    191         public void ApplicationNameTest()
    192         {
    193             HeuristicLabMembershipProvider target = new HeuristicLabMembershipProvider(); // TODO: Passenden Wert initialisieren
    194             string expected = string.Empty; // TODO: Passenden Wert initialisieren
    195             string actual;
    196             target.ApplicationName = expected;
    197             actual = target.ApplicationName;
    198             Assert.AreEqual(expected, actual);
    199             Assert.Inconclusive("Überprüfen Sie die Richtigkeit dieser Testmethode.");
    200         }
    201 
    202         /// <summary>
    203         ///Ein Test für "ValidateUser"
    204         ///</summary>
    205         [TestMethod()]
    206         public void ValidateUserTest()
    207         {
    208             HeuristicLabMembershipProvider target = new HeuristicLabMembershipProvider(); // TODO: Passenden Wert initialisieren
    209             string username = string.Empty; // TODO: Passenden Wert initialisieren
    210             string password = string.Empty; // TODO: Passenden Wert initialisieren
    211             bool expected = false; // TODO: Passenden Wert initialisieren
    212             bool actual;
    213             actual = target.ValidateUser(username, password);
    214             Assert.AreEqual(expected, actual);
    215             Assert.Inconclusive("Überprüfen Sie die Richtigkeit dieser Testmethode.");
    216         }
    217 
    218         /// <summary>
    219         ///Ein Test für "UpdateUser"
    220         ///</summary>
    221         [TestMethod()]
    222         public void UpdateUserTest()
    223         {
    224             HeuristicLabMembershipProvider target = new HeuristicLabMembershipProvider(); // TODO: Passenden Wert initialisieren
    225             MembershipUser user = null; // TODO: Passenden Wert initialisieren
    226             target.UpdateUser(user);
    227             Assert.Inconclusive("Eine Methode, die keinen Wert zurückgibt, kann nicht überprüft werden.");
    228         }
    229 
    230         /// <summary>
    231         ///Ein Test für "UnlockUser"
    232         ///</summary>
    233         [TestMethod()]
    234         public void UnlockUserTest()
    235         {
    236             HeuristicLabMembershipProvider target = new HeuristicLabMembershipProvider(); // TODO: Passenden Wert initialisieren
    237             string userName = string.Empty; // TODO: Passenden Wert initialisieren
    238             bool expected = false; // TODO: Passenden Wert initialisieren
    239             bool actual;
    240             actual = target.UnlockUser(userName);
    241             Assert.AreEqual(expected, actual);
    242             Assert.Inconclusive("Überprüfen Sie die Richtigkeit dieser Testmethode.");
    243         }
    244 
    245         /// <summary>
    246         ///Ein Test für "ResetPassword"
    247         ///</summary>
    248         [TestMethod()]
    249         public void ResetPasswordTest()
    250         {
    251             HeuristicLabMembershipProvider target = new HeuristicLabMembershipProvider(); // TODO: Passenden Wert initialisieren
    252             string username = string.Empty; // TODO: Passenden Wert initialisieren
    253             string answer = string.Empty; // TODO: Passenden Wert initialisieren
    254             string expected = string.Empty; // TODO: Passenden Wert initialisieren
    255             string actual;
    256             actual = target.ResetPassword(username, answer);
    257             Assert.AreEqual(expected, actual);
    258             Assert.Inconclusive("Überprüfen Sie die Richtigkeit dieser Testmethode.");
    259         }
    260 
    261         /// <summary>
    262         ///Ein Test für "GetUserNameByEmail"
    263         ///</summary>
    264         [TestMethod()]
    265         public void GetUserNameByEmailTest()
    266         {
    267             HeuristicLabMembershipProvider target = new HeuristicLabMembershipProvider(); // TODO: Passenden Wert initialisieren
    268             string email = string.Empty; // TODO: Passenden Wert initialisieren
    269             string expected = string.Empty; // TODO: Passenden Wert initialisieren
    270             string actual;
    271             actual = target.GetUserNameByEmail(email);
    272             Assert.AreEqual(expected, actual);
    273             Assert.Inconclusive("Überprüfen Sie die Richtigkeit dieser Testmethode.");
    274         }
    275 
    276         /// <summary>
    277         ///Ein Test für "GetUser"
    278         ///</summary>
    279         [TestMethod()]
    280         public void GetUserTest1()
    281         {
    282             HeuristicLabMembershipProvider target = new HeuristicLabMembershipProvider(); // TODO: Passenden Wert initialisieren
    283             object providerUserKey = null; // TODO: Passenden Wert initialisieren
    284             bool userIsOnline = false; // TODO: Passenden Wert initialisieren
    285             MembershipUser expected = null; // TODO: Passenden Wert initialisieren
    286             MembershipUser actual;
    287             actual = target.GetUser(providerUserKey, userIsOnline);
    288             Assert.AreEqual(expected, actual);
    289             Assert.Inconclusive("Überprüfen Sie die Richtigkeit dieser Testmethode.");
    290         }
    291 
    292         /// <summary>
    293         ///Ein Test für "GetUser"
    294         ///</summary>
    295         [TestMethod()]
    296         public void GetUserTest()
    297         {
    298             HeuristicLabMembershipProvider target = new HeuristicLabMembershipProvider(); // TODO: Passenden Wert initialisieren
    299             string username = string.Empty; // TODO: Passenden Wert initialisieren
    300             bool userIsOnline = false; // TODO: Passenden Wert initialisieren
    301             MembershipUser expected = null; // TODO: Passenden Wert initialisieren
    302             MembershipUser actual;
    303             actual = target.GetUser(username, userIsOnline);
    304             Assert.AreEqual(expected, actual);
    305             Assert.Inconclusive("Überprüfen Sie die Richtigkeit dieser Testmethode.");
    306         }
    307 
    308         /// <summary>
    309         ///Ein Test für "GetPassword"
    310         ///</summary>
    311         [TestMethod()]
    312         public void GetPasswordTest()
    313         {
    314             HeuristicLabMembershipProvider target = new HeuristicLabMembershipProvider(); // TODO: Passenden Wert initialisieren
    315             string username = string.Empty; // TODO: Passenden Wert initialisieren
    316             string answer = string.Empty; // TODO: Passenden Wert initialisieren
    317             string expected = string.Empty; // TODO: Passenden Wert initialisieren
    318             string actual;
    319             actual = target.GetPassword(username, answer);
    320             Assert.AreEqual(expected, actual);
    321             Assert.Inconclusive("Überprüfen Sie die Richtigkeit dieser Testmethode.");
    322         }
    323 
    324         /// <summary>
    325         ///Ein Test für "GetNumberOfUsersOnline"
    326         ///</summary>
    327         [TestMethod()]
    328         public void GetNumberOfUsersOnlineTest()
    329         {
    330             HeuristicLabMembershipProvider target = new HeuristicLabMembershipProvider(); // TODO: Passenden Wert initialisieren
    331             int expected = 0; // TODO: Passenden Wert initialisieren
    332             int actual;
    333             actual = target.GetNumberOfUsersOnline();
    334             Assert.AreEqual(expected, actual);
    335             Assert.Inconclusive("Überprüfen Sie die Richtigkeit dieser Testmethode.");
    336         }
    337 
    338         /// <summary>
    339         ///Ein Test für "GetAllUsers"
    340         ///</summary>
    341         [TestMethod()]
    342         public void GetAllUsersTest()
    343         {
    344             HeuristicLabMembershipProvider target = new HeuristicLabMembershipProvider(); // TODO: Passenden Wert initialisieren
    345             int pageIndex = 0; // TODO: Passenden Wert initialisieren
    346             int pageSize = 0; // TODO: Passenden Wert initialisieren
    347             int totalRecords = 0; // TODO: Passenden Wert initialisieren
    348             int totalRecordsExpected = 0; // TODO: Passenden Wert initialisieren
    349             MembershipUserCollection expected = null; // TODO: Passenden Wert initialisieren
    350             MembershipUserCollection actual;
    351             actual = target.GetAllUsers(pageIndex, pageSize, out totalRecords);
    352             Assert.AreEqual(totalRecordsExpected, totalRecords);
    353             Assert.AreEqual(expected, actual);
    354             Assert.Inconclusive("Überprüfen Sie die Richtigkeit dieser Testmethode.");
    355         }
    356 
    357         /// <summary>
    358         ///Ein Test für "FindUsersByName"
    359         ///</summary>
    360         [TestMethod()]
    361         public void FindUsersByNameTest()
    362         {
    363             HeuristicLabMembershipProvider target = new HeuristicLabMembershipProvider(); // TODO: Passenden Wert initialisieren
    364             string usernameToMatch = string.Empty; // TODO: Passenden Wert initialisieren
    365             int pageIndex = 0; // TODO: Passenden Wert initialisieren
    366             int pageSize = 0; // TODO: Passenden Wert initialisieren
    367             int totalRecords = 0; // TODO: Passenden Wert initialisieren
    368             int totalRecordsExpected = 0; // TODO: Passenden Wert initialisieren
    369             MembershipUserCollection expected = null; // TODO: Passenden Wert initialisieren
    370             MembershipUserCollection actual;
    371             actual = target.FindUsersByName(usernameToMatch, pageIndex, pageSize, out totalRecords);
    372             Assert.AreEqual(totalRecordsExpected, totalRecords);
    373             Assert.AreEqual(expected, actual);
    374             Assert.Inconclusive("Überprüfen Sie die Richtigkeit dieser Testmethode.");
    375         }
    376 
    377         /// <summary>
    378         ///Ein Test für "FindUsersByEmail"
    379         ///</summary>
    380         [TestMethod()]
    381         public void FindUsersByEmailTest()
    382         {
    383             HeuristicLabMembershipProvider target = new HeuristicLabMembershipProvider(); // TODO: Passenden Wert initialisieren
    384             string emailToMatch = string.Empty; // TODO: Passenden Wert initialisieren
    385             int pageIndex = 0; // TODO: Passenden Wert initialisieren
    386             int pageSize = 0; // TODO: Passenden Wert initialisieren
    387             int totalRecords = 0; // TODO: Passenden Wert initialisieren
    388             int totalRecordsExpected = 0; // TODO: Passenden Wert initialisieren
    389             MembershipUserCollection expected = null; // TODO: Passenden Wert initialisieren
    390             MembershipUserCollection actual;
    391             actual = target.FindUsersByEmail(emailToMatch, pageIndex, pageSize, out totalRecords);
    392             Assert.AreEqual(totalRecordsExpected, totalRecords);
    393             Assert.AreEqual(expected, actual);
    394             Assert.Inconclusive("Überprüfen Sie die Richtigkeit dieser Testmethode.");
    395         }
    396 
    397         /// <summary>
    398         ///Ein Test für "DeleteUser"
    399         ///</summary>
    400         [TestMethod()]
    401         public void DeleteUserTest()
    402         {
    403             HeuristicLabMembershipProvider target = new HeuristicLabMembershipProvider(); // TODO: Passenden Wert initialisieren
    404             string username = string.Empty; // TODO: Passenden Wert initialisieren
    405             bool deleteAllRelatedData = false; // TODO: Passenden Wert initialisieren
    406             bool expected = false; // TODO: Passenden Wert initialisieren
    407             bool actual;
    408             actual = target.DeleteUser(username, deleteAllRelatedData);
    409             Assert.AreEqual(expected, actual);
    410             Assert.Inconclusive("Überprüfen Sie die Richtigkeit dieser Testmethode.");
    411         }
    412 
    413         /// <summary>
    414         ///Ein Test für "CreateUser"
    415         ///</summary>
    416         [TestMethod()]
    417         public void CreateUserTest()
    418         {
    419             HeuristicLabMembershipProvider target = new HeuristicLabMembershipProvider(); // TODO: Passenden Wert initialisieren
    420             string username = string.Empty; // TODO: Passenden Wert initialisieren
    421             string password = string.Empty; // TODO: Passenden Wert initialisieren
    422             string email = string.Empty; // TODO: Passenden Wert initialisieren
    423             string passwordQuestion = string.Empty; // TODO: Passenden Wert initialisieren
    424             string passwordAnswer = string.Empty; // TODO: Passenden Wert initialisieren
    425             bool isApproved = false; // TODO: Passenden Wert initialisieren
    426             object providerUserKey = null; // TODO: Passenden Wert initialisieren
    427             MembershipCreateStatus status = new MembershipCreateStatus(); // TODO: Passenden Wert initialisieren
    428             MembershipCreateStatus statusExpected = new MembershipCreateStatus(); // TODO: Passenden Wert initialisieren
    429             MembershipUser expected = null; // TODO: Passenden Wert initialisieren
    430             MembershipUser actual;
    431             actual = target.CreateUser(username, password, email, passwordQuestion, passwordAnswer, isApproved, providerUserKey, out status);
    432             Assert.AreEqual(statusExpected, status);
    433             Assert.AreEqual(expected, actual);
    434             Assert.Inconclusive("Überprüfen Sie die Richtigkeit dieser Testmethode.");
    435         }
    436 
    437         /// <summary>
    438         ///Ein Test für "ChangePasswordQuestionAndAnswer"
    439         ///</summary>
    440         [TestMethod()]
    441         public void ChangePasswordQuestionAndAnswerTest()
    442         {
    443             HeuristicLabMembershipProvider target = new HeuristicLabMembershipProvider(); // TODO: Passenden Wert initialisieren
    444             string username = string.Empty; // TODO: Passenden Wert initialisieren
    445             string password = string.Empty; // TODO: Passenden Wert initialisieren
    446             string newPasswordQuestion = string.Empty; // TODO: Passenden Wert initialisieren
    447             string newPasswordAnswer = string.Empty; // TODO: Passenden Wert initialisieren
    448             bool expected = false; // TODO: Passenden Wert initialisieren
    449             bool actual;
    450             actual = target.ChangePasswordQuestionAndAnswer(username, password, newPasswordQuestion, newPasswordAnswer);
    451             Assert.AreEqual(expected, actual);
    452             Assert.Inconclusive("Überprüfen Sie die Richtigkeit dieser Testmethode.");
    453         }
    454 
    455         /// <summary>
    456         ///Ein Test für "ChangePassword"
    457         ///</summary>
    458         [TestMethod()]
    459         public void ChangePasswordTest()
    460         {
    461             HeuristicLabMembershipProvider target = new HeuristicLabMembershipProvider(); // TODO: Passenden Wert initialisieren
    462             string username = string.Empty; // TODO: Passenden Wert initialisieren
    463             string oldPassword = string.Empty; // TODO: Passenden Wert initialisieren
    464             string newPassword = string.Empty; // TODO: Passenden Wert initialisieren
    465             bool expected = false; // TODO: Passenden Wert initialisieren
    466             bool actual;
    467             actual = target.ChangePassword(username, oldPassword, newPassword);
    468             Assert.AreEqual(expected, actual);
    469             Assert.Inconclusive("Überprüfen Sie die Richtigkeit dieser Testmethode.");
    470         }
    471 
    472         /// <summary>
    473         ///Ein Test für "HeuristicLabMembershipProvider-Konstruktor"
    474         ///</summary>
    475         [TestMethod()]
    476         public void HeuristicLabMembershipProviderConstructorTest()
    477         {
    478             HeuristicLabMembershipProvider target = new HeuristicLabMembershipProvider();
    479             Assert.Inconclusive("TODO: Code zum Überprüfen des Ziels implementieren");
    480         }
    481     }
     5namespace UnitTests {
     6
     7
     8  /// <summary>
     9  ///Dies ist eine Testklasse für "HeuristicLabMembershipProviderTest" und soll
     10  ///alle HeuristicLabMembershipProviderTest Komponententests enthalten.
     11  ///</summary>
     12  [TestClass()]
     13  public class HeuristicLabMembershipProviderTest {
     14
     15
     16    private TestContext testContextInstance;
     17
     18    /// <summary>
     19    ///Ruft den Testkontext auf, der Informationen
     20    ///über und Funktionalität für den aktuellen Testlauf bietet, oder legt diesen fest.
     21    ///</summary>
     22    public TestContext TestContext {
     23      get {
     24        return testContextInstance;
     25      }
     26      set {
     27        testContextInstance = value;
     28      }
     29    }
     30
     31    #region Zusätzliche Testattribute
     32    //
     33    //Sie können beim Verfassen Ihrer Tests die folgenden zusätzlichen Attribute verwenden:
     34    //
     35    //Mit ClassInitialize führen Sie Code aus, bevor Sie den ersten Test in der Klasse ausführen.
     36    //[ClassInitialize()]
     37    //public static void MyClassInitialize(TestContext testContext)
     38    //{
     39    //}
     40    //
     41    //Mit ClassCleanup führen Sie Code aus, nachdem alle Tests in einer Klasse ausgeführt wurden.
     42    //[ClassCleanup()]
     43    //public static void MyClassCleanup()
     44    //{
     45    //}
     46    //
     47    //Mit TestInitialize können Sie vor jedem einzelnen Test Code ausführen.
     48    //[TestInitialize()]
     49    //public void MyTestInitialize()
     50    //{
     51    //}
     52    //
     53    //Mit TestCleanup können Sie nach jedem einzelnen Test Code ausführen.
     54    //[TestCleanup()]
     55    //public void MyTestCleanup()
     56    //{
     57    //}
     58    //
     59    #endregion
     60
     61
     62    /// <summary>
     63    ///Ein Test für "RequiresUniqueEmail"
     64    ///</summary>
     65    [TestMethod()]
     66    public void RequiresUniqueEmailTest() {
     67      HeuristicLabMembershipProvider target = new HeuristicLabMembershipProvider(); // TODO: Passenden Wert initialisieren
     68      bool actual;
     69      actual = target.RequiresUniqueEmail;
     70      Assert.Inconclusive("Überprüfen Sie die Richtigkeit dieser Testmethode.");
     71    }
     72
     73    /// <summary>
     74    ///Ein Test für "RequiresQuestionAndAnswer"
     75    ///</summary>
     76    [TestMethod()]
     77    public void RequiresQuestionAndAnswerTest() {
     78      HeuristicLabMembershipProvider target = new HeuristicLabMembershipProvider(); // TODO: Passenden Wert initialisieren
     79      bool actual;
     80      actual = target.RequiresQuestionAndAnswer;
     81      Assert.Inconclusive("Überprüfen Sie die Richtigkeit dieser Testmethode.");
     82    }
     83
     84    /// <summary>
     85    ///Ein Test für "PasswordStrengthRegularExpression"
     86    ///</summary>
     87    [TestMethod()]
     88    public void PasswordStrengthRegularExpressionTest() {
     89      HeuristicLabMembershipProvider target = new HeuristicLabMembershipProvider(); // TODO: Passenden Wert initialisieren
     90      string actual;
     91      actual = target.PasswordStrengthRegularExpression;
     92      Assert.Inconclusive("Überprüfen Sie die Richtigkeit dieser Testmethode.");
     93    }
     94
     95    /// <summary>
     96    ///Ein Test für "PasswordFormat"
     97    ///</summary>
     98    [TestMethod()]
     99    public void PasswordFormatTest() {
     100      HeuristicLabMembershipProvider target = new HeuristicLabMembershipProvider(); // TODO: Passenden Wert initialisieren
     101      MembershipPasswordFormat actual;
     102      actual = target.PasswordFormat;
     103      Assert.Inconclusive("Überprüfen Sie die Richtigkeit dieser Testmethode.");
     104    }
     105
     106    /// <summary>
     107    ///Ein Test für "PasswordAttemptWindow"
     108    ///</summary>
     109    [TestMethod()]
     110    public void PasswordAttemptWindowTest() {
     111      HeuristicLabMembershipProvider target = new HeuristicLabMembershipProvider(); // TODO: Passenden Wert initialisieren
     112      int actual;
     113      actual = target.PasswordAttemptWindow;
     114      Assert.Inconclusive("Überprüfen Sie die Richtigkeit dieser Testmethode.");
     115    }
     116
     117    /// <summary>
     118    ///Ein Test für "MinRequiredPasswordLength"
     119    ///</summary>
     120    [TestMethod()]
     121    public void MinRequiredPasswordLengthTest() {
     122      HeuristicLabMembershipProvider target = new HeuristicLabMembershipProvider(); // TODO: Passenden Wert initialisieren
     123      int actual;
     124      actual = target.MinRequiredPasswordLength;
     125      Assert.Inconclusive("Überprüfen Sie die Richtigkeit dieser Testmethode.");
     126    }
     127
     128    /// <summary>
     129    ///Ein Test für "MinRequiredNonAlphanumericCharacters"
     130    ///</summary>
     131    [TestMethod()]
     132    public void MinRequiredNonAlphanumericCharactersTest() {
     133      HeuristicLabMembershipProvider target = new HeuristicLabMembershipProvider(); // TODO: Passenden Wert initialisieren
     134      int actual;
     135      actual = target.MinRequiredNonAlphanumericCharacters;
     136      Assert.Inconclusive("Überprüfen Sie die Richtigkeit dieser Testmethode.");
     137    }
     138
     139    /// <summary>
     140    ///Ein Test für "MaxInvalidPasswordAttempts"
     141    ///</summary>
     142    [TestMethod()]
     143    public void MaxInvalidPasswordAttemptsTest() {
     144      HeuristicLabMembershipProvider target = new HeuristicLabMembershipProvider(); // TODO: Passenden Wert initialisieren
     145      int actual;
     146      actual = target.MaxInvalidPasswordAttempts;
     147      Assert.Inconclusive("Überprüfen Sie die Richtigkeit dieser Testmethode.");
     148    }
     149
     150    /// <summary>
     151    ///Ein Test für "EnablePasswordRetrieval"
     152    ///</summary>
     153    [TestMethod()]
     154    public void EnablePasswordRetrievalTest() {
     155      HeuristicLabMembershipProvider target = new HeuristicLabMembershipProvider(); // TODO: Passenden Wert initialisieren
     156      bool actual;
     157      actual = target.EnablePasswordRetrieval;
     158      Assert.Inconclusive("Überprüfen Sie die Richtigkeit dieser Testmethode.");
     159    }
     160
     161    /// <summary>
     162    ///Ein Test für "EnablePasswordReset"
     163    ///</summary>
     164    [TestMethod()]
     165    public void EnablePasswordResetTest() {
     166      HeuristicLabMembershipProvider target = new HeuristicLabMembershipProvider(); // TODO: Passenden Wert initialisieren
     167      bool actual;
     168      actual = target.EnablePasswordReset;
     169      Assert.Inconclusive("Überprüfen Sie die Richtigkeit dieser Testmethode.");
     170    }
     171
     172    /// <summary>
     173    ///Ein Test für "ApplicationName"
     174    ///</summary>
     175    [TestMethod()]
     176    public void ApplicationNameTest() {
     177      HeuristicLabMembershipProvider target = new HeuristicLabMembershipProvider(); // TODO: Passenden Wert initialisieren
     178      string expected = string.Empty; // TODO: Passenden Wert initialisieren
     179      string actual;
     180      target.ApplicationName = expected;
     181      actual = target.ApplicationName;
     182      Assert.AreEqual(expected, actual);
     183      Assert.Inconclusive("Überprüfen Sie die Richtigkeit dieser Testmethode.");
     184    }
     185
     186    /// <summary>
     187    ///Ein Test für "ValidateUser"
     188    ///</summary>
     189    [TestMethod()]
     190    public void ValidateUserTest() {
     191      HeuristicLabMembershipProvider target = new HeuristicLabMembershipProvider(); // TODO: Passenden Wert initialisieren
     192      string username = string.Empty; // TODO: Passenden Wert initialisieren
     193      string password = string.Empty; // TODO: Passenden Wert initialisieren
     194      bool expected = false; // TODO: Passenden Wert initialisieren
     195      bool actual;
     196      actual = target.ValidateUser(username, password);
     197      Assert.AreEqual(expected, actual);
     198      Assert.Inconclusive("Überprüfen Sie die Richtigkeit dieser Testmethode.");
     199    }
     200
     201    /// <summary>
     202    ///Ein Test für "UpdateUser"
     203    ///</summary>
     204    [TestMethod()]
     205    public void UpdateUserTest() {
     206      HeuristicLabMembershipProvider target = new HeuristicLabMembershipProvider(); // TODO: Passenden Wert initialisieren
     207      MembershipUser user = null; // TODO: Passenden Wert initialisieren
     208      target.UpdateUser(user);
     209      Assert.Inconclusive("Eine Methode, die keinen Wert zurückgibt, kann nicht überprüft werden.");
     210    }
     211
     212    /// <summary>
     213    ///Ein Test für "UnlockUser"
     214    ///</summary>
     215    [TestMethod()]
     216    public void UnlockUserTest() {
     217      HeuristicLabMembershipProvider target = new HeuristicLabMembershipProvider(); // TODO: Passenden Wert initialisieren
     218      string userName = string.Empty; // TODO: Passenden Wert initialisieren
     219      bool expected = false; // TODO: Passenden Wert initialisieren
     220      bool actual;
     221      actual = target.UnlockUser(userName);
     222      Assert.AreEqual(expected, actual);
     223      Assert.Inconclusive("Überprüfen Sie die Richtigkeit dieser Testmethode.");
     224    }
     225
     226    /// <summary>
     227    ///Ein Test für "ResetPassword"
     228    ///</summary>
     229    [TestMethod()]
     230    public void ResetPasswordTest() {
     231      HeuristicLabMembershipProvider target = new HeuristicLabMembershipProvider(); // TODO: Passenden Wert initialisieren
     232      string username = string.Empty; // TODO: Passenden Wert initialisieren
     233      string answer = string.Empty; // TODO: Passenden Wert initialisieren
     234      string expected = string.Empty; // TODO: Passenden Wert initialisieren
     235      string actual;
     236      actual = target.ResetPassword(username, answer);
     237      Assert.AreEqual(expected, actual);
     238      Assert.Inconclusive("Überprüfen Sie die Richtigkeit dieser Testmethode.");
     239    }
     240
     241    /// <summary>
     242    ///Ein Test für "GetUserNameByEmail"
     243    ///</summary>
     244    [TestMethod()]
     245    public void GetUserNameByEmailTest() {
     246      HeuristicLabMembershipProvider target = new HeuristicLabMembershipProvider(); // TODO: Passenden Wert initialisieren
     247      string email = string.Empty; // TODO: Passenden Wert initialisieren
     248      string expected = string.Empty; // TODO: Passenden Wert initialisieren
     249      string actual;
     250      actual = target.GetUserNameByEmail(email);
     251      Assert.AreEqual(expected, actual);
     252      Assert.Inconclusive("Überprüfen Sie die Richtigkeit dieser Testmethode.");
     253    }
     254
     255    /// <summary>
     256    ///Ein Test für "GetUser"
     257    ///</summary>
     258    [TestMethod()]
     259    public void GetUserTest1() {
     260      HeuristicLabMembershipProvider target = new HeuristicLabMembershipProvider(); // TODO: Passenden Wert initialisieren
     261      object providerUserKey = null; // TODO: Passenden Wert initialisieren
     262      bool userIsOnline = false; // TODO: Passenden Wert initialisieren
     263      MembershipUser expected = null; // TODO: Passenden Wert initialisieren
     264      MembershipUser actual;
     265      actual = target.GetUser(providerUserKey, userIsOnline);
     266      Assert.AreEqual(expected, actual);
     267      Assert.Inconclusive("Überprüfen Sie die Richtigkeit dieser Testmethode.");
     268    }
     269
     270    /// <summary>
     271    ///Ein Test für "GetUser"
     272    ///</summary>
     273    [TestMethod()]
     274    public void GetUserTest() {
     275      HeuristicLabMembershipProvider target = new HeuristicLabMembershipProvider(); // TODO: Passenden Wert initialisieren
     276      string username = string.Empty; // TODO: Passenden Wert initialisieren
     277      bool userIsOnline = false; // TODO: Passenden Wert initialisieren
     278      MembershipUser expected = null; // TODO: Passenden Wert initialisieren
     279      MembershipUser actual;
     280      actual = target.GetUser(username, userIsOnline);
     281      Assert.AreEqual(expected, actual);
     282      Assert.Inconclusive("Überprüfen Sie die Richtigkeit dieser Testmethode.");
     283    }
     284
     285    /// <summary>
     286    ///Ein Test für "GetPassword"
     287    ///</summary>
     288    [TestMethod()]
     289    public void GetPasswordTest() {
     290      HeuristicLabMembershipProvider target = new HeuristicLabMembershipProvider(); // TODO: Passenden Wert initialisieren
     291      string username = string.Empty; // TODO: Passenden Wert initialisieren
     292      string answer = string.Empty; // TODO: Passenden Wert initialisieren
     293      string expected = string.Empty; // TODO: Passenden Wert initialisieren
     294      string actual;
     295      actual = target.GetPassword(username, answer);
     296      Assert.AreEqual(expected, actual);
     297      Assert.Inconclusive("Überprüfen Sie die Richtigkeit dieser Testmethode.");
     298    }
     299
     300    /// <summary>
     301    ///Ein Test für "GetNumberOfUsersOnline"
     302    ///</summary>
     303    [TestMethod()]
     304    public void GetNumberOfUsersOnlineTest() {
     305      HeuristicLabMembershipProvider target = new HeuristicLabMembershipProvider(); // TODO: Passenden Wert initialisieren
     306      int expected = 0; // TODO: Passenden Wert initialisieren
     307      int actual;
     308      actual = target.GetNumberOfUsersOnline();
     309      Assert.AreEqual(expected, actual);
     310      Assert.Inconclusive("Überprüfen Sie die Richtigkeit dieser Testmethode.");
     311    }
     312
     313    /// <summary>
     314    ///Ein Test für "GetAllUsers"
     315    ///</summary>
     316    [TestMethod()]
     317    public void GetAllUsersTest() {
     318      HeuristicLabMembershipProvider target = new HeuristicLabMembershipProvider(); // TODO: Passenden Wert initialisieren
     319      int pageIndex = 0; // TODO: Passenden Wert initialisieren
     320      int pageSize = 0; // TODO: Passenden Wert initialisieren
     321      int totalRecords = 0; // TODO: Passenden Wert initialisieren
     322      int totalRecordsExpected = 0; // TODO: Passenden Wert initialisieren
     323      MembershipUserCollection expected = null; // TODO: Passenden Wert initialisieren
     324      MembershipUserCollection actual;
     325      actual = target.GetAllUsers(pageIndex, pageSize, out totalRecords);
     326      Assert.AreEqual(totalRecordsExpected, totalRecords);
     327      Assert.AreEqual(expected, actual);
     328      Assert.Inconclusive("Überprüfen Sie die Richtigkeit dieser Testmethode.");
     329    }
     330
     331    /// <summary>
     332    ///Ein Test für "FindUsersByName"
     333    ///</summary>
     334    [TestMethod()]
     335    public void FindUsersByNameTest() {
     336      HeuristicLabMembershipProvider target = new HeuristicLabMembershipProvider(); // TODO: Passenden Wert initialisieren
     337      string usernameToMatch = string.Empty; // TODO: Passenden Wert initialisieren
     338      int pageIndex = 0; // TODO: Passenden Wert initialisieren
     339      int pageSize = 0; // TODO: Passenden Wert initialisieren
     340      int totalRecords = 0; // TODO: Passenden Wert initialisieren
     341      int totalRecordsExpected = 0; // TODO: Passenden Wert initialisieren
     342      MembershipUserCollection expected = null; // TODO: Passenden Wert initialisieren
     343      MembershipUserCollection actual;
     344      actual = target.FindUsersByName(usernameToMatch, pageIndex, pageSize, out totalRecords);
     345      Assert.AreEqual(totalRecordsExpected, totalRecords);
     346      Assert.AreEqual(expected, actual);
     347      Assert.Inconclusive("Überprüfen Sie die Richtigkeit dieser Testmethode.");
     348    }
     349
     350    /// <summary>
     351    ///Ein Test für "FindUsersByEmail"
     352    ///</summary>
     353    [TestMethod()]
     354    public void FindUsersByEmailTest() {
     355      HeuristicLabMembershipProvider target = new HeuristicLabMembershipProvider(); // TODO: Passenden Wert initialisieren
     356      string emailToMatch = string.Empty; // TODO: Passenden Wert initialisieren
     357      int pageIndex = 0; // TODO: Passenden Wert initialisieren
     358      int pageSize = 0; // TODO: Passenden Wert initialisieren
     359      int totalRecords = 0; // TODO: Passenden Wert initialisieren
     360      int totalRecordsExpected = 0; // TODO: Passenden Wert initialisieren
     361      MembershipUserCollection expected = null; // TODO: Passenden Wert initialisieren
     362      MembershipUserCollection actual;
     363      actual = target.FindUsersByEmail(emailToMatch, pageIndex, pageSize, out totalRecords);
     364      Assert.AreEqual(totalRecordsExpected, totalRecords);
     365      Assert.AreEqual(expected, actual);
     366      Assert.Inconclusive("Überprüfen Sie die Richtigkeit dieser Testmethode.");
     367    }
     368
     369    /// <summary>
     370    ///Ein Test für "DeleteUser"
     371    ///</summary>
     372    [TestMethod()]
     373    public void DeleteUserTest() {
     374      HeuristicLabMembershipProvider target = new HeuristicLabMembershipProvider(); // TODO: Passenden Wert initialisieren
     375      string username = string.Empty; // TODO: Passenden Wert initialisieren
     376      bool deleteAllRelatedData = false; // TODO: Passenden Wert initialisieren
     377      bool expected = false; // TODO: Passenden Wert initialisieren
     378      bool actual;
     379      actual = target.DeleteUser(username, deleteAllRelatedData);
     380      Assert.AreEqual(expected, actual);
     381      Assert.Inconclusive("Überprüfen Sie die Richtigkeit dieser Testmethode.");
     382    }
     383
     384    /// <summary>
     385    ///Ein Test für "CreateUser"
     386    ///</summary>
     387    [TestMethod()]
     388    public void CreateUserTest() {
     389      HeuristicLabMembershipProvider target = new HeuristicLabMembershipProvider(); // TODO: Passenden Wert initialisieren
     390      string username = string.Empty; // TODO: Passenden Wert initialisieren
     391      string password = string.Empty; // TODO: Passenden Wert initialisieren
     392      string email = string.Empty; // TODO: Passenden Wert initialisieren
     393      string passwordQuestion = string.Empty; // TODO: Passenden Wert initialisieren
     394      string passwordAnswer = string.Empty; // TODO: Passenden Wert initialisieren
     395      bool isApproved = false; // TODO: Passenden Wert initialisieren
     396      object providerUserKey = null; // TODO: Passenden Wert initialisieren
     397      MembershipCreateStatus status = new MembershipCreateStatus(); // TODO: Passenden Wert initialisieren
     398      MembershipCreateStatus statusExpected = new MembershipCreateStatus(); // TODO: Passenden Wert initialisieren
     399      MembershipUser expected = null; // TODO: Passenden Wert initialisieren
     400      MembershipUser actual;
     401      actual = target.CreateUser(username, password, email, passwordQuestion, passwordAnswer, isApproved, providerUserKey, out status);
     402      Assert.AreEqual(statusExpected, status);
     403      Assert.AreEqual(expected, actual);
     404      Assert.Inconclusive("Überprüfen Sie die Richtigkeit dieser Testmethode.");
     405    }
     406
     407    /// <summary>
     408    ///Ein Test für "ChangePasswordQuestionAndAnswer"
     409    ///</summary>
     410    [TestMethod()]
     411    public void ChangePasswordQuestionAndAnswerTest() {
     412      HeuristicLabMembershipProvider target = new HeuristicLabMembershipProvider(); // TODO: Passenden Wert initialisieren
     413      string username = string.Empty; // TODO: Passenden Wert initialisieren
     414      string password = string.Empty; // TODO: Passenden Wert initialisieren
     415      string newPasswordQuestion = string.Empty; // TODO: Passenden Wert initialisieren
     416      string newPasswordAnswer = string.Empty; // TODO: Passenden Wert initialisieren
     417      bool expected = false; // TODO: Passenden Wert initialisieren
     418      bool actual;
     419      actual = target.ChangePasswordQuestionAndAnswer(username, password, newPasswordQuestion, newPasswordAnswer);
     420      Assert.AreEqual(expected, actual);
     421      Assert.Inconclusive("Überprüfen Sie die Richtigkeit dieser Testmethode.");
     422    }
     423
     424    /// <summary>
     425    ///Ein Test für "ChangePassword"
     426    ///</summary>
     427    [TestMethod()]
     428    public void ChangePasswordTest() {
     429      HeuristicLabMembershipProvider target = new HeuristicLabMembershipProvider(); // TODO: Passenden Wert initialisieren
     430      string username = string.Empty; // TODO: Passenden Wert initialisieren
     431      string oldPassword = string.Empty; // TODO: Passenden Wert initialisieren
     432      string newPassword = string.Empty; // TODO: Passenden Wert initialisieren
     433      bool expected = false; // TODO: Passenden Wert initialisieren
     434      bool actual;
     435      actual = target.ChangePassword(username, oldPassword, newPassword);
     436      Assert.AreEqual(expected, actual);
     437      Assert.Inconclusive("Überprüfen Sie die Richtigkeit dieser Testmethode.");
     438    }
     439
     440    /// <summary>
     441    ///Ein Test für "HeuristicLabMembershipProvider-Konstruktor"
     442    ///</summary>
     443    [TestMethod()]
     444    public void HeuristicLabMembershipProviderConstructorTest() {
     445      HeuristicLabMembershipProvider target = new HeuristicLabMembershipProvider();
     446      Assert.Inconclusive("TODO: Code zum Überprüfen des Ziels implementieren");
     447    }
     448  }
    482449}
  • branches/HeuristicLab.Services.Authentication Prototype/UnitTests/HeuristicLabRoleProviderTest.cs

    r3932 r3939  
    11using Service.Provider;
    22using Microsoft.VisualStudio.TestTools.UnitTesting;
    3 namespace UnitTests
    4 {
    5    
    6    
    7     /// <summary>
    8     ///Dies ist eine Testklasse für "HeuristicLabRoleProviderTest" und soll
    9     ///alle HeuristicLabRoleProviderTest Komponententests enthalten.
    10     ///</summary>
    11     [TestClass()]
    12     public class HeuristicLabRoleProviderTest
    13     {
    14 
    15 
    16         private TestContext testContextInstance;
    17 
    18         /// <summary>
    19         ///Ruft den Testkontext auf, der Informationen
    20         ///über und Funktionalität für den aktuellen Testlauf bietet, oder legt diesen fest.
    21         ///</summary>
    22         public TestContext TestContext
    23         {
    24             get
    25             {
    26                 return testContextInstance;
    27             }
    28             set
    29             {
    30                 testContextInstance = value;
    31             }
    32         }
    33 
    34         #region Zusätzliche Testattribute
    35         //
    36         //Sie können beim Verfassen Ihrer Tests die folgenden zusätzlichen Attribute verwenden:
    37         //
    38         //Mit ClassInitialize führen Sie Code aus, bevor Sie den ersten Test in der Klasse ausführen.
    39         //[ClassInitialize()]
    40         //public static void MyClassInitialize(TestContext testContext)
    41         //{
    42         //}
    43         //
    44         //Mit ClassCleanup führen Sie Code aus, nachdem alle Tests in einer Klasse ausgeführt wurden.
    45         //[ClassCleanup()]
    46         //public static void MyClassCleanup()
    47         //{
    48         //}
    49         //
    50         //Mit TestInitialize können Sie vor jedem einzelnen Test Code ausführen.
    51         //[TestInitialize()]
    52         //public void MyTestInitialize()
    53         //{
    54         //}
    55         //
    56         //Mit TestCleanup können Sie nach jedem einzelnen Test Code ausführen.
    57         //[TestCleanup()]
    58         //public void MyTestCleanup()
    59         //{
    60         //}
    61         //
    62         #endregion
    63 
    64 
    65         /// <summary>
    66         ///Ein Test für "ApplicationName"
    67         ///</summary>
    68         [TestMethod()]
    69         public void ApplicationNameTest()
    70         {
    71             HeuristicLabRoleProvider target = new HeuristicLabRoleProvider(); // TODO: Passenden Wert initialisieren
    72             string expected = string.Empty; // TODO: Passenden Wert initialisieren
    73             string actual;
    74             target.ApplicationName = expected;
    75             actual = target.ApplicationName;
    76             Assert.AreEqual(expected, actual);
    77             Assert.Inconclusive("Überprüfen Sie die Richtigkeit dieser Testmethode.");
    78         }
    79 
    80         /// <summary>
    81         ///Ein Test für "RoleExists"
    82         ///</summary>
    83         [TestMethod()]
    84         public void RoleExistsTest()
    85         {
    86             HeuristicLabRoleProvider target = new HeuristicLabRoleProvider(); // TODO: Passenden Wert initialisieren
    87             string roleName = string.Empty; // TODO: Passenden Wert initialisieren
    88             bool expected = false; // TODO: Passenden Wert initialisieren
    89             bool actual;
    90             actual = target.RoleExists(roleName);
    91             Assert.AreEqual(expected, actual);
    92             Assert.Inconclusive("Überprüfen Sie die Richtigkeit dieser Testmethode.");
    93         }
    94 
    95         /// <summary>
    96         ///Ein Test für "RemoveUsersFromRoles"
    97         ///</summary>
    98         [TestMethod()]
    99         public void RemoveUsersFromRolesTest()
    100         {
    101             HeuristicLabRoleProvider target = new HeuristicLabRoleProvider(); // TODO: Passenden Wert initialisieren
    102             string[] usernames = null; // TODO: Passenden Wert initialisieren
    103             string[] roleNames = null; // TODO: Passenden Wert initialisieren
    104             target.RemoveUsersFromRoles(usernames, roleNames);
    105             Assert.Inconclusive("Eine Methode, die keinen Wert zurückgibt, kann nicht überprüft werden.");
    106         }
    107 
    108         /// <summary>
    109         ///Ein Test für "IsUserInRole"
    110         ///</summary>
    111         [TestMethod()]
    112         public void IsUserInRoleTest()
    113         {
    114             HeuristicLabRoleProvider target = new HeuristicLabRoleProvider(); // TODO: Passenden Wert initialisieren
    115             string username = string.Empty; // TODO: Passenden Wert initialisieren
    116             string roleName = string.Empty; // TODO: Passenden Wert initialisieren
    117             bool expected = false; // TODO: Passenden Wert initialisieren
    118             bool actual;
    119             actual = target.IsUserInRole(username, roleName);
    120             Assert.AreEqual(expected, actual);
    121             Assert.Inconclusive("Überprüfen Sie die Richtigkeit dieser Testmethode.");
    122         }
    123 
    124         /// <summary>
    125         ///Ein Test für "GetUsersInRole"
    126         ///</summary>
    127         [TestMethod()]
    128         public void GetUsersInRoleTest()
    129         {
    130             HeuristicLabRoleProvider target = new HeuristicLabRoleProvider(); // TODO: Passenden Wert initialisieren
    131             string roleName = string.Empty; // TODO: Passenden Wert initialisieren
    132             string[] expected = null; // TODO: Passenden Wert initialisieren
    133             string[] actual;
    134             actual = target.GetUsersInRole(roleName);
    135             Assert.AreEqual(expected, actual);
    136             Assert.Inconclusive("Überprüfen Sie die Richtigkeit dieser Testmethode.");
    137         }
    138 
    139         /// <summary>
    140         ///Ein Test für "GetRolesForUser"
    141         ///</summary>
    142         [TestMethod()]
    143         public void GetRolesForUserTest()
    144         {
    145             HeuristicLabRoleProvider target = new HeuristicLabRoleProvider(); // TODO: Passenden Wert initialisieren
    146             string username = string.Empty; // TODO: Passenden Wert initialisieren
    147             string[] expected = null; // TODO: Passenden Wert initialisieren
    148             string[] actual;
    149             actual = target.GetRolesForUser(username);
    150             Assert.AreEqual(expected, actual);
    151             Assert.Inconclusive("Überprüfen Sie die Richtigkeit dieser Testmethode.");
    152         }
    153 
    154         /// <summary>
    155         ///Ein Test für "GetAllRoles"
    156         ///</summary>
    157         [TestMethod()]
    158         public void GetAllRolesTest()
    159         {
    160             HeuristicLabRoleProvider target = new HeuristicLabRoleProvider(); // TODO: Passenden Wert initialisieren
    161             string[] expected = null; // TODO: Passenden Wert initialisieren
    162             string[] actual;
    163             actual = target.GetAllRoles();
    164             Assert.AreEqual(expected, actual);
    165             Assert.Inconclusive("Überprüfen Sie die Richtigkeit dieser Testmethode.");
    166         }
    167 
    168         /// <summary>
    169         ///Ein Test für "FindUsersInRole"
    170         ///</summary>
    171         [TestMethod()]
    172         public void FindUsersInRoleTest()
    173         {
    174             HeuristicLabRoleProvider target = new HeuristicLabRoleProvider(); // TODO: Passenden Wert initialisieren
    175             string roleName = string.Empty; // TODO: Passenden Wert initialisieren
    176             string usernameToMatch = string.Empty; // TODO: Passenden Wert initialisieren
    177             string[] expected = null; // TODO: Passenden Wert initialisieren
    178             string[] actual;
    179             actual = target.FindUsersInRole(roleName, usernameToMatch);
    180             Assert.AreEqual(expected, actual);
    181             Assert.Inconclusive("Überprüfen Sie die Richtigkeit dieser Testmethode.");
    182         }
    183 
    184         /// <summary>
    185         ///Ein Test für "DeleteRole"
    186         ///</summary>
    187         [TestMethod()]
    188         public void DeleteRoleTest()
    189         {
    190             HeuristicLabRoleProvider target = new HeuristicLabRoleProvider(); // TODO: Passenden Wert initialisieren
    191             string roleName = string.Empty; // TODO: Passenden Wert initialisieren
    192             bool throwOnPopulatedRole = false; // TODO: Passenden Wert initialisieren
    193             bool expected = false; // TODO: Passenden Wert initialisieren
    194             bool actual;
    195             actual = target.DeleteRole(roleName, throwOnPopulatedRole);
    196             Assert.AreEqual(expected, actual);
    197             Assert.Inconclusive("Überprüfen Sie die Richtigkeit dieser Testmethode.");
    198         }
    199 
    200         /// <summary>
    201         ///Ein Test für "CreateRole"
    202         ///</summary>
    203         [TestMethod()]
    204         public void CreateRoleTest()
    205         {
    206             HeuristicLabRoleProvider target = new HeuristicLabRoleProvider(); // TODO: Passenden Wert initialisieren
    207             string roleName = string.Empty; // TODO: Passenden Wert initialisieren
    208             target.CreateRole(roleName);
    209             Assert.Inconclusive("Eine Methode, die keinen Wert zurückgibt, kann nicht überprüft werden.");
    210         }
    211 
    212         /// <summary>
    213         ///Ein Test für "AddUsersToRoles"
    214         ///</summary>
    215         [TestMethod()]
    216         public void AddUsersToRolesTest()
    217         {
    218             HeuristicLabRoleProvider target = new HeuristicLabRoleProvider(); // TODO: Passenden Wert initialisieren
    219             string[] usernames = null; // TODO: Passenden Wert initialisieren
    220             string[] roleNames = null; // TODO: Passenden Wert initialisieren
    221             target.AddUsersToRoles(usernames, roleNames);
    222             Assert.Inconclusive("Eine Methode, die keinen Wert zurückgibt, kann nicht überprüft werden.");
    223         }
    224 
    225         /// <summary>
    226         ///Ein Test für "HeuristicLabRoleProvider-Konstruktor"
    227         ///</summary>
    228         [TestMethod()]
    229         public void HeuristicLabRoleProviderConstructorTest()
    230         {
    231             HeuristicLabRoleProvider target = new HeuristicLabRoleProvider();
    232             Assert.Inconclusive("TODO: Code zum Überprüfen des Ziels implementieren");
    233         }
    234     }
     3namespace UnitTests {
     4
     5
     6  /// <summary>
     7  ///Dies ist eine Testklasse für "HeuristicLabRoleProviderTest" und soll
     8  ///alle HeuristicLabRoleProviderTest Komponententests enthalten.
     9  ///</summary>
     10  [TestClass()]
     11  public class HeuristicLabRoleProviderTest {
     12
     13
     14    private TestContext testContextInstance;
     15
     16    /// <summary>
     17    ///Ruft den Testkontext auf, der Informationen
     18    ///über und Funktionalität für den aktuellen Testlauf bietet, oder legt diesen fest.
     19    ///</summary>
     20    public TestContext TestContext {
     21      get {
     22        return testContextInstance;
     23      }
     24      set {
     25        testContextInstance = value;
     26      }
     27    }
     28
     29    #region Zusätzliche Testattribute
     30    //
     31    //Sie können beim Verfassen Ihrer Tests die folgenden zusätzlichen Attribute verwenden:
     32    //
     33    //Mit ClassInitialize führen Sie Code aus, bevor Sie den ersten Test in der Klasse ausführen.
     34    //[ClassInitialize()]
     35    //public static void MyClassInitialize(TestContext testContext)
     36    //{
     37    //}
     38    //
     39    //Mit ClassCleanup führen Sie Code aus, nachdem alle Tests in einer Klasse ausgeführt wurden.
     40    //[ClassCleanup()]
     41    //public static void MyClassCleanup()
     42    //{
     43    //}
     44    //
     45    //Mit TestInitialize können Sie vor jedem einzelnen Test Code ausführen.
     46    //[TestInitialize()]
     47    //public void MyTestInitialize()
     48    //{
     49    //}
     50    //
     51    //Mit TestCleanup können Sie nach jedem einzelnen Test Code ausführen.
     52    //[TestCleanup()]
     53    //public void MyTestCleanup()
     54    //{
     55    //}
     56    //
     57    #endregion
     58
     59
     60    /// <summary>
     61    ///Ein Test für "ApplicationName"
     62    ///</summary>
     63    [TestMethod()]
     64    public void ApplicationNameTest() {
     65      HeuristicLabRoleProvider target = new HeuristicLabRoleProvider(); // TODO: Passenden Wert initialisieren
     66      string expected = string.Empty; // TODO: Passenden Wert initialisieren
     67      string actual;
     68      target.ApplicationName = expected;
     69      actual = target.ApplicationName;
     70      Assert.AreEqual(expected, actual);
     71      Assert.Inconclusive("Überprüfen Sie die Richtigkeit dieser Testmethode.");
     72    }
     73
     74    /// <summary>
     75    ///Ein Test für "RoleExists"
     76    ///</summary>
     77    [TestMethod()]
     78    public void RoleExistsTest() {
     79      HeuristicLabRoleProvider target = new HeuristicLabRoleProvider(); // TODO: Passenden Wert initialisieren
     80      string roleName = string.Empty; // TODO: Passenden Wert initialisieren
     81      bool expected = false; // TODO: Passenden Wert initialisieren
     82      bool actual;
     83      actual = target.RoleExists(roleName);
     84      Assert.AreEqual(expected, actual);
     85      Assert.Inconclusive("Überprüfen Sie die Richtigkeit dieser Testmethode.");
     86    }
     87
     88    /// <summary>
     89    ///Ein Test für "RemoveUsersFromRoles"
     90    ///</summary>
     91    [TestMethod()]
     92    public void RemoveUsersFromRolesTest() {
     93      HeuristicLabRoleProvider target = new HeuristicLabRoleProvider(); // TODO: Passenden Wert initialisieren
     94      string[] usernames = null; // TODO: Passenden Wert initialisieren
     95      string[] roleNames = null; // TODO: Passenden Wert initialisieren
     96      target.RemoveUsersFromRoles(usernames, roleNames);
     97      Assert.Inconclusive("Eine Methode, die keinen Wert zurückgibt, kann nicht überprüft werden.");
     98    }
     99
     100    /// <summary>
     101    ///Ein Test für "IsUserInRole"
     102    ///</summary>
     103    [TestMethod()]
     104    public void IsUserInRoleTest() {
     105      HeuristicLabRoleProvider target = new HeuristicLabRoleProvider(); // TODO: Passenden Wert initialisieren
     106      string username = string.Empty; // TODO: Passenden Wert initialisieren
     107      string roleName = string.Empty; // TODO: Passenden Wert initialisieren
     108      bool expected = false; // TODO: Passenden Wert initialisieren
     109      bool actual;
     110      actual = target.IsUserInRole(username, roleName);
     111      Assert.AreEqual(expected, actual);
     112      Assert.Inconclusive("Überprüfen Sie die Richtigkeit dieser Testmethode.");
     113    }
     114
     115    /// <summary>
     116    ///Ein Test für "GetUsersInRole"
     117    ///</summary>
     118    [TestMethod()]
     119    public void GetUsersInRoleTest() {
     120      HeuristicLabRoleProvider target = new HeuristicLabRoleProvider(); // TODO: Passenden Wert initialisieren
     121      string roleName = string.Empty; // TODO: Passenden Wert initialisieren
     122      string[] expected = null; // TODO: Passenden Wert initialisieren
     123      string[] actual;
     124      actual = target.GetUsersInRole(roleName);
     125      Assert.AreEqual(expected, actual);
     126      Assert.Inconclusive("Überprüfen Sie die Richtigkeit dieser Testmethode.");
     127    }
     128
     129    /// <summary>
     130    ///Ein Test für "GetRolesForUser"
     131    ///</summary>
     132    [TestMethod()]
     133    public void GetRolesForUserTest() {
     134      HeuristicLabRoleProvider target = new HeuristicLabRoleProvider(); // TODO: Passenden Wert initialisieren
     135      string username = string.Empty; // TODO: Passenden Wert initialisieren
     136      string[] expected = null; // TODO: Passenden Wert initialisieren
     137      string[] actual;
     138      actual = target.GetRolesForUser(username);
     139      Assert.AreEqual(expected, actual);
     140      Assert.Inconclusive("Überprüfen Sie die Richtigkeit dieser Testmethode.");
     141    }
     142
     143    /// <summary>
     144    ///Ein Test für "GetAllRoles"
     145    ///</summary>
     146    [TestMethod()]
     147    public void GetAllRolesTest() {
     148      HeuristicLabRoleProvider target = new HeuristicLabRoleProvider(); // TODO: Passenden Wert initialisieren
     149      string[] expected = null; // TODO: Passenden Wert initialisieren
     150      string[] actual;
     151      actual = target.GetAllRoles();
     152      Assert.AreEqual(expected, actual);
     153      Assert.Inconclusive("Überprüfen Sie die Richtigkeit dieser Testmethode.");
     154    }
     155
     156    /// <summary>
     157    ///Ein Test für "FindUsersInRole"
     158    ///</summary>
     159    [TestMethod()]
     160    public void FindUsersInRoleTest() {
     161      HeuristicLabRoleProvider target = new HeuristicLabRoleProvider(); // TODO: Passenden Wert initialisieren
     162      string roleName = string.Empty; // TODO: Passenden Wert initialisieren
     163      string usernameToMatch = string.Empty; // TODO: Passenden Wert initialisieren
     164      string[] expected = null; // TODO: Passenden Wert initialisieren
     165      string[] actual;
     166      actual = target.FindUsersInRole(roleName, usernameToMatch);
     167      Assert.AreEqual(expected, actual);
     168      Assert.Inconclusive("Überprüfen Sie die Richtigkeit dieser Testmethode.");
     169    }
     170
     171    /// <summary>
     172    ///Ein Test für "DeleteRole"
     173    ///</summary>
     174    [TestMethod()]
     175    public void DeleteRoleTest() {
     176      HeuristicLabRoleProvider target = new HeuristicLabRoleProvider(); // TODO: Passenden Wert initialisieren
     177      string roleName = string.Empty; // TODO: Passenden Wert initialisieren
     178      bool throwOnPopulatedRole = false; // TODO: Passenden Wert initialisieren
     179      bool expected = false; // TODO: Passenden Wert initialisieren
     180      bool actual;
     181      actual = target.DeleteRole(roleName, throwOnPopulatedRole);
     182      Assert.AreEqual(expected, actual);
     183      Assert.Inconclusive("Überprüfen Sie die Richtigkeit dieser Testmethode.");
     184    }
     185
     186    /// <summary>
     187    ///Ein Test für "CreateRole"
     188    ///</summary>
     189    [TestMethod()]
     190    public void CreateRoleTest() {
     191      HeuristicLabRoleProvider target = new HeuristicLabRoleProvider(); // TODO: Passenden Wert initialisieren
     192      string roleName = string.Empty; // TODO: Passenden Wert initialisieren
     193      target.CreateRole(roleName);
     194      Assert.Inconclusive("Eine Methode, die keinen Wert zurückgibt, kann nicht überprüft werden.");
     195    }
     196
     197    /// <summary>
     198    ///Ein Test für "AddUsersToRoles"
     199    ///</summary>
     200    [TestMethod()]
     201    public void AddUsersToRolesTest() {
     202      HeuristicLabRoleProvider target = new HeuristicLabRoleProvider(); // TODO: Passenden Wert initialisieren
     203      string[] usernames = null; // TODO: Passenden Wert initialisieren
     204      string[] roleNames = null; // TODO: Passenden Wert initialisieren
     205      target.AddUsersToRoles(usernames, roleNames);
     206      Assert.Inconclusive("Eine Methode, die keinen Wert zurückgibt, kann nicht überprüft werden.");
     207    }
     208
     209    /// <summary>
     210    ///Ein Test für "HeuristicLabRoleProvider-Konstruktor"
     211    ///</summary>
     212    [TestMethod()]
     213    public void HeuristicLabRoleProviderConstructorTest() {
     214      HeuristicLabRoleProvider target = new HeuristicLabRoleProvider();
     215      Assert.Inconclusive("TODO: Code zum Überprüfen des Ziels implementieren");
     216    }
     217  }
    235218}
Note: See TracChangeset for help on using the changeset viewer.