Exemple #1
0
        private void ConstructorEnabledObjectLiterals()
        {
            Test("Two instances of constructor-supporting [ObjectLiteral] single-string-property class where string values match", assert =>
            {
                assert.StrictEqual(
                    ComponentPropsHelpers.DoPropsReferencesMatch(
                        new ConstructorObjectLiteralSingleStringPropertyClass("abc"),
                        new ConstructorObjectLiteralSingleStringPropertyClass("abc")
                        ),
                    true
                    );
            });

            Test("Two instances of constructor-supporting [ObjectLiteral] single-function-property class where functions are equivalent anonymous static lambdas that Bridge lifts to named methods", assert =>
            {
                assert.StrictEqual(
                    ComponentPropsHelpers.DoPropsReferencesMatch(
                        new ConstructorObjectLiteralSingleFunctionPropertyClass(value => Console.WriteLine(value)),
                        new ConstructorObjectLiteralSingleFunctionPropertyClass(value => Console.WriteLine(value))
                        ),
                    true
                    );
            });

            Test("Two instances of constructor-supporting [ObjectLiteral] single-function-property class where functions are equivalent bound functions", assert =>
            {
                assert.StrictEqual(
                    ComponentPropsHelpers.DoPropsReferencesMatch(
                        new ConstructorObjectLiteralSingleFunctionPropertyClass(InstanceMethod),
                        new ConstructorObjectLiteralSingleFunctionPropertyClass(InstanceMethod)
                        ),
                    true
                    );
            });

            // These two props instances will be given then exact same reference, so this is a really easy case
            Test("Two instances of constructor-supporting [ObjectLiteral] single-function-property class where functions are the same function property on a known reference", assert =>
            {
                var bindToTarget = new SingleFunctionPropertyClass(value => Console.WriteLine(value));
                assert.StrictEqual(
                    ComponentPropsHelpers.DoPropsReferencesMatch(
                        new ConstructorObjectLiteralSingleFunctionPropertyClass(bindToTarget.OnChange),
                        new ConstructorObjectLiteralSingleFunctionPropertyClass(bindToTarget.OnChange)
                        ),
                    true
                    );
            });
        }
Exemple #2
0
        private void RegularBridgeClasses()
        {
            Test("Two instances of single-string-property class where string values match", assert =>
            {
                assert.StrictEqual(
                    ComponentPropsHelpers.DoPropsReferencesMatch(
                        new SingleStringPropertyClass("abc"),
                        new SingleStringPropertyClass("abc")
                        ),
                    true
                    );
            });

            Test("Two instances of single-function-property class where functions are equivalent anonymous static lambdas that Bridge lifts to named methods", assert =>
            {
                assert.StrictEqual(
                    ComponentPropsHelpers.DoPropsReferencesMatch(
                        new SingleFunctionPropertyClass(value => Console.WriteLine(value)),
                        new SingleFunctionPropertyClass(value => Console.WriteLine(value))
                        ),
                    true
                    );
            });

            Test("Two instances of single-function-property class where functions are equivalent bound functions", assert =>
            {
                assert.StrictEqual(
                    ComponentPropsHelpers.DoPropsReferencesMatch(
                        new SingleFunctionPropertyClass(InstanceMethod),
                        new SingleFunctionPropertyClass(InstanceMethod)
                        ),
                    true
                    );
            });

            // These two props instances will be given then exact same reference, so this is a really easy case
            Test("Two instances of single-function-property class where functions are the same function property on a known reference", assert =>
            {
                var bindToTarget = new SingleFunctionPropertyClass(value => Console.WriteLine(value));
                assert.StrictEqual(
                    ComponentPropsHelpers.DoPropsReferencesMatch(
                        new SingleFunctionPropertyClass(bindToTarget.OnChange),
                        new SingleFunctionPropertyClass(bindToTarget.OnChange)
                        ),
                    true
                    );
            });

            // These C# lamdbas are clearly equivalent but it's not possible for the JavaScript code to know this for sure because it can only see the function content
            // of them and can't tell for sure that they haven't been bound to different instances using JavaScript's bind facility. If the solution is 100% Bridge then
            // this shouldn't be the same case because Bridge will bind functions (using its own mechanism) when it has to. However, if the solution ISN'T entirely from
            // Bridge-compiled C# code then there could be other code creating bound functions and then it would not be reliable to compare the two functions by their
            // content. Currently, there is a switch for this behaviour that is set to false and within an internal class and so it can't be set to true by consumers
            // of Bridge.React (apart from this project, which has access to internal-accessibility members).
            Test("Two instances of single-function-property class where functions are equivalent anonymous static lambdas that Bridge can't lift to named methods (EXPERIMENTAL)", assert =>
            {
                var outerValue = "abc";                 // Having the lambdas access this value prevents them from being lifted into their own methods
                var optimiseFunctionComparisonsBasedOnSolutionBeingPureBridge = ComponentPropsHelpers.OptimiseFunctionComparisonsBasedOnSolutionBeingPureBridge;
                try
                {
                    ComponentPropsHelpers.OptimiseFunctionComparisonsBasedOnSolutionBeingPureBridge = true;
                    assert.StrictEqual(
                        ComponentPropsHelpers.DoPropsReferencesMatch(
                            new SingleFunctionPropertyClass(value => Console.WriteLine(outerValue + ":" + value)),
                            new SingleFunctionPropertyClass(value => Console.WriteLine(outerValue + ":" + value))
                            ),
                        true
                        );
                }
                finally
                {
                    ComponentPropsHelpers.OptimiseFunctionComparisonsBasedOnSolutionBeingPureBridge = optimiseFunctionComparisonsBasedOnSolutionBeingPureBridge;
                }
            });

            Test("Two instance of a single-property class where property has custom Equals implementation (where both values are considered equivalent)", assert =>
            {
                assert.StrictEqual(
                    ComponentPropsHelpers.DoPropsReferencesMatch(
                        new SingleCaseInsensitiveStringPropertyClass(new CaseInsensitiveString("abc")),
                        new SingleCaseInsensitiveStringPropertyClass(new CaseInsensitiveString("ABC"))
                        ),
                    true
                    );
            });

            // TODO: Check with nulls

            // TODO: Add false-result comparisons
        }