
using Xunit;
using Xunit;
using System;
using System.Reflection;

namespace ConsoleApp {
    public class ProgramTests {
        [Fact(DisplayName = "User class contains private password field")] 
        public void User_HasPrivatePasswordField() {
            var type = typeof(User);
            var field = type.GetField("password", BindingFlags.NonPublic | BindingFlags.Instance);
            Assert.NotNull(field);
            Assert.True(field.IsPrivate, "The password field must be private.");
        }

        [Fact(DisplayName = "Username property is public and settable")]
        public void User_UsernamePropertyIsPublicAndSettable() {
            var type = typeof(User);
            var prop = type.GetProperty("Username");
            Assert.NotNull(prop);
            Assert.True(prop.CanRead && prop.CanWrite, "Username must be gettable and settable.");
            Assert.True(prop.GetGetMethod().IsPublic, "Username getter must be public.");
            Assert.True(prop.GetSetMethod().IsPublic, "Username setter must be public.");
        }

        [Fact(DisplayName = "User has protected password validation method")]
        public void User_HasProtectedPasswordValidationMethod() {
            var type = typeof(User);
            var method = type.GetMethod("ValidatePassword", BindingFlags.NonPublic | BindingFlags.Instance);
            Assert.NotNull(method);
            Assert.True(method.IsFamily, "ValidatePassword must be protected.");
            Assert.Equal(typeof(bool), method.ReturnType);
            Assert.Equal(1, method.GetParameters().Length);
            Assert.Equal(typeof(string), method.GetParameters()[0].ParameterType);
        }

        [Fact(DisplayName = "Password field is not accessible from outside")]
        public void User_PasswordNotAccessible() {
            var user = new User("alice", "secret");
            var type = typeof(User);
            var fields = type.GetFields(BindingFlags.Public | BindingFlags.Instance);
            foreach(var field in fields) {
                Assert.NotEqual("password", field.Name);
            }
        }

        [Fact(DisplayName = "TryLogin uses password validation correctly")]
        public void User_TryLoginUsesValidation() {
            var sw = new System.IO.StringWriter();
            Console.SetOut(sw);
            User user = new User("bob", "mypassword");
            user.TryLogin("mypassword");
            user.TryLogin("wrong");
            string output = sw.ToString();
            Assert.Contains("Login successful", output);
            Assert.Contains("Login failed", output);
            Console.SetOut(new System.IO.StreamWriter(Console.OpenStandardOutput()) { AutoFlush = true });
        }
    }
}

ProgramTests.cs

Master the art of building robust C# classes through hands-on drills and engaging theory. Explore constructors, encapsulation, access modifiers, static classes, and more, with real-world inspired challenges.

Dive into the world of constructors in C#. Learn how to initialize objects, use constructor overloading, and apply best practices for flexible class instantiation.

Explore the principles of class design, encapsulation, and how to protect and organize data using access modifiers.

Learn how to use static classes and members for shared data and utility functionality in C#.

Delve into advanced class construction topics: composition vs inheritance, and refactoring structs into classes for more complex scenarios.

Challenge: Secure User Class

Solution