Adding inheritance test

6 files changed, 499 insertions, 0 deletions

diff --git a/matlab/test/Ice/inheritance/AllTests.m b/matlab/test/Ice/inheritance/AllTests.m
new file mode 100644
index 00000000000..b1f75a3d1ce
--- /dev/null
+++ b/matlab/test/Ice/inheritance/AllTests.m
@@ -0,0 +1,228 @@
+%{
+**********************************************************************
+
+Copyright (c) 2003-2017 ZeroC, Inc. All rights reserved.
+
+This copy of Ice is licensed to you under the terms described in the
+ICE_LICENSE file included in this distribution.
+
+**********************************************************************
+%}
+
+classdef AllTests
+    methods(Static)
+        function r = allTests(app)
+            import test.Ice.inheritance.Test.*;
+
+            communicator = app.communicator();
+
+            fprintf('testing stringToProxy... ');
+
+            ref = ['initial:', app.getTestEndpoint(0, '')];
+            base = communicator.stringToProxy(ref);
+            assert(~isempty(base));
+            fprintf('ok\n');
+
+            fprintf('testing checked cast... ');
+
+            initial = InitialPrx.checkedCast(base);
+            assert(~isempty(initial));
+            assert(initial == base);
+            fprintf('ok\n');
+
+            fprintf('getting proxies for class hierarchy... ');
+
+            ca = initial.caop();
+            cb = initial.cbop();
+            cc = initial.ccop();
+            cd = initial.cdop();
+            assert(ca ~= cb);
+            assert(ca ~= cc);
+            assert(ca ~= cd);
+            assert(cb ~= cc);
+            assert(cb ~= cd);
+            assert(cc ~= cd);
+            fprintf('ok\n');
+
+            fprintf('getting proxies for interface hierarchy... ');
+
+            ia = initial.iaop();
+            ib1 = initial.ib1op();
+            ib2 = initial.ib2op();
+            ic = initial.icop();
+            assert(ia ~= ib1);
+            assert(ia ~= ib2);
+            assert(ia ~= ic);
+            assert(ib1 ~= ic);
+            assert(ib2 ~= ic);
+            fprintf('ok\n');
+
+            fprintf('invoking proxy operations on class hierarchy... ');
+
+            cao = [];
+            cbo = [];
+            cco = [];
+
+            cao = ca.caop(ca);
+            assert(cao == ca);
+            cao = ca.caop(cb);
+            assert(cao == cb);
+            cao = ca.caop(cc);
+            assert(cao == cc);
+            cao = cb.caop(ca);
+            assert(cao == ca);
+            cao = cb.caop(cb);
+            assert(cao == cb);
+            cao = cb.caop(cc);
+            assert(cao == cc);
+            cao = cc.caop(ca);
+            assert(cao == ca);
+            cao = cc.caop(cb);
+            assert(cao == cb);
+            cao = cc.caop(cc);
+            assert(cao == cc);
+
+            cao = cb.cbop(cb);
+            assert(cao == cb);
+            cbo = cb.cbop(cb);
+            assert(cbo == cb);
+            cao = cb.cbop(cc);
+            assert(cao == cc);
+            cbo = cb.cbop(cc);
+            assert(cbo == cc);
+            cao = cc.cbop(cb);
+            assert(cao == cb);
+            cbo = cc.cbop(cb);
+            assert(cbo == cb);
+            cao = cc.cbop(cc);
+            assert(cao == cc);
+            cbo = cc.cbop(cc);
+            assert(cbo == cc);
+
+            cao = cc.ccop(cc);
+            assert(cao == cc);
+            cbo = cc.ccop(cc);
+            assert(cbo == cc);
+            cco = cc.ccop(cc);
+            assert(cco == cc);
+            fprintf('ok\n');
+
+            fprintf('ditto, but for interface hierarchy... ');
+
+            iao = [];
+            ib1o = [];
+            ib2o = [];
+            ico = [];
+
+            iao = ia.iaop(ia);
+            assert(iao == ia);
+            iao = ia.iaop(ib1);
+            assert(iao == ib1);
+            iao = ia.iaop(ib2);
+            assert(iao == ib2);
+            iao = ia.iaop(ic);
+            assert(iao == ic);
+            iao = ib1.iaop(ia);
+            assert(iao == ia);
+            iao = ib1.iaop(ib1);
+            assert(iao == ib1);
+            iao = ib1.iaop(ib2);
+            assert(iao == ib2);
+            iao = ib1.iaop(ic);
+            assert(iao == ic);
+            iao = ib2.iaop(ia);
+            assert(iao == ia);
+            iao = ib2.iaop(ib1);
+            assert(iao == ib1);
+            iao = ib2.iaop(ib2);
+            assert(iao == ib2);
+            iao = ib2.iaop(ic);
+            assert(iao == ic);
+            iao = ic.iaop(ia);
+            assert(iao == ia);
+            iao = ic.iaop(ib1);
+            assert(iao == ib1);
+            iao = ic.iaop(ib2);
+            assert(iao == ib2);
+            iao = ic.iaop(ic);
+            assert(iao == ic);
+
+            iao = ib1.ib1op(ib1);
+            assert(iao == ib1);
+            ib1o = ib1.ib1op(ib1);
+            assert(ib1o == ib1);
+            iao = ib1.ib1op(ic);
+            assert(iao == ic);
+            ib1o = ib1.ib1op(ic);
+            assert(ib1o == ic);
+            iao = ic.ib1op(ib1);
+            assert(iao == ib1);
+            ib1o = ic.ib1op(ib1);
+            assert(ib1o == ib1);
+            iao = ic.ib1op(ic);
+            assert(iao == ic);
+            ib1o = ic.ib1op(ic);
+            assert(ib1o == ic);
+
+            iao = ib2.ib2op(ib2);
+            assert(iao == ib2);
+            ib2o = ib2.ib2op(ib2);
+            assert(ib2o == ib2);
+            iao = ib2.ib2op(ic);
+            assert(iao == ic);
+            ib2o = ib2.ib2op(ic);
+            assert(ib2o == ic);
+            iao = ic.ib2op(ib2);
+            assert(iao == ib2);
+            ib2o = ic.ib2op(ib2);
+            assert(ib2o == ib2);
+            iao = ic.ib2op(ic);
+            assert(iao == ic);
+            ib2o = ic.ib2op(ic);
+            assert(ib2o == ic);
+
+            iao = ic.icop(ic);
+            assert(iao == ic);
+            ib1o = ic.icop(ic);
+            assert(ib1o == ic);
+            ib2o = ic.icop(ic);
+            assert(ib2o == ic);
+            ico = ic.icop(ic);
+            assert(ico == ic);
+            fprintf('ok\n');
+
+            fprintf('ditto, but for class implementing interfaces... ');
+
+            cao = cd.caop(cd);
+            assert(cao == cd);
+            cbo = cd.cbop(cd);
+            assert(cbo == cd);
+            cco = cd.ccop(cd);
+            assert(cco == cd);
+
+            iao = cd.iaop(cd);
+            assert(iao == cd);
+            ib1o = cd.ib1op(cd);
+            assert(ib1o == cd);
+            ib2o = cd.ib2op(cd);
+            assert(ib2o == cd);
+
+            cao = cd.cdop(cd);
+            assert(cao == cd);
+            cbo = cd.cdop(cd);
+            assert(cbo == cd);
+            cco = cd.cdop(cd);
+            assert(cco == cd);
+
+            iao = cd.cdop(cd);
+            assert(iao == cd);
+            ib1o = cd.cdop(cd);
+            assert(ib1o == cd);
+            ib2o = cd.cdop(cd);
+            assert(ib2o == cd);
+            fprintf('ok\n');
+
+            r = initial;
+        end
+    end
+end
diff --git a/matlab/test/Ice/inheritance/Application.m b/matlab/test/Ice/inheritance/Application.m
new file mode 100644
index 00000000000..4735c1cd057
--- /dev/null
+++ b/matlab/test/Ice/inheritance/Application.m
@@ -0,0 +1,143 @@
+%{
+**********************************************************************
+
+Copyright (c) 2003-2017 ZeroC, Inc. All rights reserved.
+
+This copy of Ice is licensed to you under the terms described in the
+ICE_LICENSE file included in this distribution.
+
+**********************************************************************
+%}
+
+classdef (Abstract) Application < handle
+    methods(Sealed)
+        %
+        % main() initializes the Communicator, calls run(), and destroys
+        % the Communicator upon return from run(). It thereby handles
+        % all exceptions properly, i.e., error messages are printed
+        % if exceptions propagate to main(), and the Communicator is
+        % always destroyed, regardless of exceptions.
+        %
+        function r = main(obj, appName, varargin)
+            if ~isempty(obj.communicator_)
+                printf('%s: only one instance of the Application class can be used', appName);
+                r = 1;
+                return;
+            end
+
+            obj.testName_ = appName;
+
+            args = {};
+            initializationData = [];
+
+            if length(varargin) >= 1
+                args = varargin{1};
+            end
+            if length(varargin) >= 2
+                initializationData = varargin{2};
+            end
+
+            %
+            % We parse the properties here to extract Ice.ProgramName.
+            %
+            if isempty(initializationData)
+                [initializationData, args] = obj.getInitData(args);
+            end
+
+            if ~isempty(initializationData)
+                initData = initializationData.clone();
+            else
+                initData = Ice.InitializationData();
+            end
+
+            [initData.properties_, args] = Ice.createProperties(args, initData.properties_);
+
+            status = 0;
+
+            try
+                [communicator, args] = Ice.initialize(args, initData);
+                obj.communicator_ = communicator;
+
+                status = obj.run(args);
+            catch ex
+                fprintf('%s: caught %s', obj.testName_, ex.identifier);
+                disp(getReport(ex, 'extended'));
+                status = 1;
+            end
+            obj.communicator_.destroy();
+            obj.communicator_ = [];
+
+            r = status;
+        end
+        function r = initialize(obj, varargin)
+            assert(length(varargin) <= 1);
+            if length(varargin) == 0
+                r = Ice.initialize();
+            else
+                r = Ice.initialize(varargin{1});
+            end
+        end
+        function r = appName(obj)
+            r = obj.testName_;
+        end
+        function r = communicator(obj)
+            r = obj.communicator_;
+        end
+        function r = createInitializationData(obj)
+            initData = Ice.InitializationData();
+            r = initData;
+        end
+        function r = getTestEndpoint(obj, num, prot)
+            r = Application.getTestEndpointWithProperties(obj.communicator_.getProperties(), num, prot);
+        end
+        function r = getTestHost(obj)
+            r = Application.getTestHostWithProperties(obj.communicator_.getProperties());
+        end
+        function r = getTestProtocol(obj)
+            r = Application.getTestProtocolWithProperties(obj.communicator_.getProperties());
+        end
+        function r = getTestPort(obj, num)
+            r = Application.getTestPortWithProperties(obj.communicator_.getProperties(), num);
+        end
+    end
+    methods(Static)
+        function r = getTestEndpointWithProperties(props, num, prot)
+            protocol = prot;
+            if length(protocol) == 0
+                protocol = props.getPropertyWithDefault('Ice.Default.Protocol', 'default');
+            end
+
+            basePort = props.getPropertyAsIntWithDefault('Test.BasePort', 12010);
+
+            r = sprintf('%s -p %d', protocol, basePort + num);
+        end
+        function r = getTestHostWithProperties(props)
+            r = props.getPropertyWithDefault('Ice.Default.Host', '127.0.0.1');
+        end
+        function r = getTestProtocolWithProperties(props)
+            r = props.getPropertyWithDefault('Ice.Default.Protocol', 'tcp');
+        end
+        function r = getTestPortWithProperties(props, num)
+            r = props.getPropertyAsIntWithDefault('Test.BasePort', 12010) + num;
+        end
+    end
+    methods(Abstract)
+        r = run(obj, args)
+    end
+    methods(Access=protected)
+        %
+        % Hook to override the initialization data. This hook is
+        % necessary because some properties must be set prior to
+        % communicator initialization.
+        %
+        function [initData, remArgs] = getInitData(obj, args)
+            initData = obj.createInitializationData();
+            [initData.properties_, remArgs] = Ice.createProperties(args);
+            remArgs = initData.properties_.parseCommandLineOptions('Test', remArgs);
+        end
+    end
+    properties(Access=private)
+        testName_
+        communicator_
+    end
+end
diff --git a/matlab/test/Ice/inheritance/Client.m b/matlab/test/Ice/inheritance/Client.m
new file mode 100644
index 00000000000..00b8798d2b8
--- /dev/null
+++ b/matlab/test/Ice/inheritance/Client.m
@@ -0,0 +1,37 @@
+%{
+**********************************************************************
+
+Copyright (c) 2003-2017 ZeroC, Inc. All rights reserved.
+
+This copy of Ice is licensed to you under the terms described in the
+ICE_LICENSE file included in this distribution.
+
+**********************************************************************
+%}
+
+classdef Client < Application
+    methods
+        function r = run(obj, args)
+            initial = AllTests.allTests(obj);
+            initial.shutdown();
+            r = 0;
+        end
+    end
+    methods(Access=protected)
+        function [r, remArgs] = getInitData(obj, args)
+            [initData, remArgs] = getInitData@Application(obj, args);
+            initData.properties_.setProperty('Ice.Package.Test', 'test.Ice.inheritance');
+            r = initData;
+        end
+    end
+    methods(Static)
+        function start(args)
+            addpath('generated');
+            if ~libisloaded('icematlab')
+                loadlibrary('icematlab')
+            end
+            c = Client();
+            status = c.main('Client', args);
+        end
+    end
+end
diff --git a/matlab/test/Ice/inheritance/Test.ice b/matlab/test/Ice/inheritance/Test.ice
new file mode 100644
index 00000000000..a69bc817104
--- /dev/null
+++ b/matlab/test/Ice/inheritance/Test.ice
@@ -0,0 +1,86 @@
+// **********************************************************************
+//
+// Copyright (c) 2003-2017 ZeroC, Inc. All rights reserved.
+//
+// This copy of Ice is licensed to you under the terms described in the
+// ICE_LICENSE file included in this distribution.
+//
+// **********************************************************************
+
+#pragma once
+
+[["matlab:package:test.Ice.inheritance"]]
+[["suppress-warning:deprecated"]] // For classes with operations
+
+module Test
+{
+
+module MA
+{
+
+interface IA
+{
+    IA* iaop(IA* p);
+}
+
+class CA
+{
+    CA* caop(CA* p);
+}
+
+}
+
+module MB
+{
+
+interface IB1 extends MA::IA
+{
+    IB1* ib1op(IB1* p);
+}
+
+interface IB2 extends MA::IA
+{
+    IB2* ib2op(IB2* p);
+}
+
+class CB extends MA::CA
+{
+    CB* cbop(CB* p);
+}
+
+}
+
+module MA
+{
+
+interface IC extends MB::IB1, MB::IB2
+{
+    IC* icop(IC* p);
+}
+
+class CC extends MB::CB
+{
+    CC* ccop(CC* p);
+}
+
+class CD extends CC implements MB::IB1, MB::IB2
+{
+    CD* cdop(CD* p);
+}
+
+}
+
+interface Initial
+{
+    void shutdown();
+    MA::CA* caop();
+    MB::CB* cbop();
+    MA::CC* ccop();
+    MA::CD* cdop();
+    MA::IA* iaop();
+    MB::IB1* ib1op();
+    MB::IB2* ib2op();
+    MA::IC* icop();
+}
+
+}
diff --git a/matlab/test/Ice/inheritance/generated/.gitignore b/matlab/test/Ice/inheritance/generated/.gitignore
new file mode 100644
index 00000000000..39af5887579
--- /dev/null
+++ b/matlab/test/Ice/inheritance/generated/.gitignore
@@ -0,0 +1 @@
+# Dummy file, so that git retains this otherwise empty directory.
diff --git a/matlab/test/Ice/inheritance/runTest.m b/matlab/test/Ice/inheritance/runTest.m
new file mode 100644
index 00000000000..ca3eaa751c8
--- /dev/null
+++ b/matlab/test/Ice/inheritance/runTest.m
@@ -0,0 +1,4 @@
+function runTest(varargin)
+    Client.start(varargin);
+    quit
+end