@sumsub/cordova-idensic-mobile-sdk-plugin 1.18.1

package/demo/plugins/cordova-plugin-whitelist/src/android/WhitelistPlugin.java

@@ -0,0 +1,161 @@
+/*
+       Licensed to the Apache Software Foundation (ASF) under one
+       or more contributor license agreements.  See the NOTICE file
+       distributed with this work for additional information
+       regarding copyright ownership.  The ASF licenses this file
+       to you under the Apache License, Version 2.0 (the
+       "License"); you may not use this file except in compliance
+       with the License.  You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+       Unless required by applicable law or agreed to in writing,
+       software distributed under the License is distributed on an
+       "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+       KIND, either express or implied.  See the License for the
+       specific language governing permissions and limitations
+       under the License.
+*/
+
+package org.apache.cordova.whitelist;
+
+import org.apache.cordova.CordovaPlugin;
+import org.apache.cordova.ConfigXmlParser;
+import org.apache.cordova.LOG;
+import org.apache.cordova.Whitelist;
+import org.xmlpull.v1.XmlPullParser;
+
+import android.content.Context;
+
+public class WhitelistPlugin extends CordovaPlugin {
+    private static final String LOG_TAG = "WhitelistPlugin";
+    private Whitelist allowedNavigations;
+    private Whitelist allowedIntents;
+    private Whitelist allowedRequests;
+
+    // Used when instantiated via reflection by PluginManager
+    public WhitelistPlugin() {
+    }
+    // These can be used by embedders to allow Java-configuration of whitelists.
+    public WhitelistPlugin(Context context) {
+        this(new Whitelist(), new Whitelist(), null);
+        new CustomConfigXmlParser().parse(context);
+    }
+    public WhitelistPlugin(XmlPullParser xmlParser) {
+        this(new Whitelist(), new Whitelist(), null);
+        new CustomConfigXmlParser().parse(xmlParser);
+    }
+    public WhitelistPlugin(Whitelist allowedNavigations, Whitelist allowedIntents, Whitelist allowedRequests) {
+        if (allowedRequests == null) {
+            allowedRequests = new Whitelist();
+            allowedRequests.addWhiteListEntry("file:///*", false);
+            allowedRequests.addWhiteListEntry("data:*", false);
+        }
+        this.allowedNavigations = allowedNavigations;
+        this.allowedIntents = allowedIntents;
+        this.allowedRequests = allowedRequests;
+    }
+    @Override
+    public void pluginInitialize() {
+        if (allowedNavigations == null) {
+            allowedNavigations = new Whitelist();
+            allowedIntents = new Whitelist();
+            allowedRequests = new Whitelist();
+            new CustomConfigXmlParser().parse(webView.getContext());
+        }
+    }
+
+    private class CustomConfigXmlParser extends ConfigXmlParser {
+        @Override
+        public void handleStartTag(XmlPullParser xml) {
+            String strNode = xml.getName();
+            if (strNode.equals("content")) {
+                String startPage = xml.getAttributeValue(null, "src");
+                allowedNavigations.addWhiteListEntry(startPage, false);
+            } else if (strNode.equals("allow-navigation")) {
+                String origin = xml.getAttributeValue(null, "href");
+                if ("*".equals(origin)) {
+                    allowedNavigations.addWhiteListEntry("http://*/*", false);
+                    allowedNavigations.addWhiteListEntry("https://*/*", false);
+                    allowedNavigations.addWhiteListEntry("data:*", false);
+                } else {
+                    allowedNavigations.addWhiteListEntry(origin, false);
+                }
+            } else if (strNode.equals("allow-intent")) {
+                String origin = xml.getAttributeValue(null, "href");
+                allowedIntents.addWhiteListEntry(origin, false);
+            } else if (strNode.equals("access")) {
+                String origin = xml.getAttributeValue(null, "origin");
+                String subdomains = xml.getAttributeValue(null, "subdomains");
+                boolean external = (xml.getAttributeValue(null, "launch-external") != null);
+                if (origin != null) {
+                    if (external) {
+                        LOG.w(LOG_TAG, "Found <access launch-external> within config.xml. Please use <allow-intent> instead.");
+                        allowedIntents.addWhiteListEntry(origin, (subdomains != null) && (subdomains.compareToIgnoreCase("true") == 0));
+                    } else {
+                        if ("*".equals(origin)) {
+                            allowedRequests.addWhiteListEntry("http://*/*", false);
+                            allowedRequests.addWhiteListEntry("https://*/*", false);
+                        } else {
+                            allowedRequests.addWhiteListEntry(origin, (subdomains != null) && (subdomains.compareToIgnoreCase("true") == 0));
+                        }
+                    }
+                }
+            }
+        }
+        @Override
+        public void handleEndTag(XmlPullParser xml) {
+        }
+    }
+
+    @Override
+    public Boolean shouldAllowNavigation(String url) {
+        if (allowedNavigations.isUrlWhiteListed(url)) {
+            return true;
+        }
+        return null; // Default policy
+    }
+
+    @Override
+    public Boolean shouldAllowRequest(String url) {
+        if (Boolean.TRUE == shouldAllowNavigation(url)) {
+            return true;
+        }
+        if (allowedRequests.isUrlWhiteListed(url)) {
+            return true;
+        }
+        return null; // Default policy
+    }
+
+    @Override
+    public Boolean shouldOpenExternalUrl(String url) {
+        if (allowedIntents.isUrlWhiteListed(url)) {
+            return true;
+        }
+        return null; // Default policy
+    }
+
+    public Whitelist getAllowedNavigations() {
+        return allowedNavigations;
+    }
+
+    public void setAllowedNavigations(Whitelist allowedNavigations) {
+        this.allowedNavigations = allowedNavigations;
+    }
+
+    public Whitelist getAllowedIntents() {
+        return allowedIntents;
+    }
+
+    public void setAllowedIntents(Whitelist allowedIntents) {
+        this.allowedIntents = allowedIntents;
+    }
+
+    public Whitelist getAllowedRequests() {
+        return allowedRequests;
+    }
+
+    public void setAllowedRequests(Whitelist allowedRequests) {
+        this.allowedRequests = allowedRequests;
+    }
+}

package/demo/plugins/cordova-plugin-whitelist/tests/README.md

@@ -0,0 +1,53 @@
+---
+ license: Licensed to the Apache Software Foundation (ASF) under one
+         or more contributor license agreements.  See the NOTICE file
+         distributed with this work for additional information
+         regarding copyright ownership.  The ASF licenses this file
+         to you under the Apache License, Version 2.0 (the
+         "License"); you may not use this file except in compliance
+         with the License.  You may obtain a copy of the License at
+
+           http://www.apache.org/licenses/LICENSE-2.0
+
+         Unless required by applicable law or agreed to in writing,
+         software distributed under the License is distributed on an
+         "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+         KIND, either express or implied.  See the License for the
+         specific language governing permissions and limitations
+         under the License.
+---
+
+# cordova-plugin-whitelist-tests
+
+This are an [optional JavaScript interface](#whitelist) to the core Cordova Whitelist functionality and the test plugin that uses it to test cordova-plugin-whitelist.
+
+## Whitelist
+
+> The `whitelist` object provides an interface for testing whether arbitrary
+> URLs are allowed by the currently active configuration, or would be allowed
+> by a given set of whitelist patterns.
+
+### Methods
+
+- cordova.whitelist.match
+- cordova.whitelist.test
+
+#### cordova.whitelist.match
+
+Indicates whether a given URL would be allowed by a set of Whitelist URL
+patterns.
+
+    cordova.whitelist.match(url, patterns, callback);
+
+`callback` will be invoked with a boolean argument indicating whether the
+url matches the set of patterns.
+
+#### cordova.whitelist.test
+
+Indicates whether a given URL would be allowed by the current application
+configuration.
+
+    cordova.whitelist.test(url, callback);
+
+`callback` will be invoked with a boolean argument indicating whether the
+url is currently whitelisted.

package/demo/plugins/cordova-plugin-whitelist/tests/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "cordova-plugin-whitelist-tests",
+  "version": "1.3.4",
+  "description": "",
+  "cordova": {
+    "id": "cordova-plugin-whitelist-tests",
+    "platforms": []
+  },
+  "keywords": [
+    "ecosystem:cordova"
+  ],
+  "author": "",
+  "license": "Apache 2.0"
+}
+

package/demo/plugins/cordova-plugin-whitelist/tests/plugin.xml

@@ -0,0 +1,56 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<!--
+  Licensed to the Apache Software Foundation (ASF) under one
+  or more contributor license agreements.  See the NOTICE file
+  distributed with this work for additional information
+  regarding copyright ownership.  The ASF licenses this file
+  to you under the Apache License, Version 2.0 (the
+  "License"); you may not use this file except in compliance
+  with the License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing,
+  software distributed under the License is distributed on an
+  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+  KIND, either express or implied.  See the License for the
+  specific language governing permissions and limitations
+  under the License.
+-->
+
+<plugin xmlns="http://cordova.apache.org/ns/plugins/1.0"
+           id="cordova-plugin-whitelist-tests"
+      version="1.3.4">
+    <name>Cordova Plugin Whitelist Tests</name>
+    <license>Apache 2.0</license>
+
+    <js-module src="tests.js" name="tests">
+    </js-module>
+    
+    <js-module src="www/whitelist.js" name="whitelist">
+        <clobbers target="cordova.whitelist" />
+    </js-module>
+
+    <!-- android -->
+    <platform name="android">
+        <config-file target="res/xml/config.xml" parent="/*">
+            <feature name="WhitelistAPI" >
+                <param name="android-package" value="org.apache.cordova.test.WhitelistAPI"/>
+            </feature>
+        </config-file>
+
+        <source-file src="src/android/WhitelistAPI.java" target-dir="src/org/apache/cordova/test" />
+
+        <!-- remove <access origin="*" /> -->
+        <hook type="after_prepare" src="scripts/remove-access.js"/>
+
+        <!-- add whitelist configuration the tests test for -->
+        <config-file target="config.xml" parent="/*">
+            <allow-navigation href="http://*.apache.org" />
+            <allow-navigation href="https://*.apache.org" />
+        </config-file>
+
+    </platform>
+
+</plugin>

package/demo/plugins/cordova-plugin-whitelist/tests/scripts/remove-access.js

@@ -0,0 +1,19 @@
+var fs = require('fs');
+var path = require('path');
+var rootdir = "";
+var file = path.join(rootdir, "platforms/android/app/src/main/res/xml/config.xml");
+
+fs.readFile( file, "utf8", function( err, data )
+{
+    if (err)
+        return console.log( err );
+
+    var result = data;
+    result = result.replace( "<access origin=\"*\" />", "" );
+
+    fs.writeFile( file, result, "utf8", function( err )
+    {
+        if (err)
+            return console.log( err );
+    } );
+} );

package/demo/plugins/cordova-plugin-whitelist/tests/src/android/WhitelistAPI.java

@@ -0,0 +1,90 @@
+/*
+       Licensed to the Apache Software Foundation (ASF) under one
+       or more contributor license agreements.  See the NOTICE file
+       distributed with this work for additional information
+       regarding copyright ownership.  The ASF licenses this file
+       to you under the Apache License, Version 2.0 (the
+       "License"); you may not use this file except in compliance
+       with the License.  You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+       Unless required by applicable law or agreed to in writing,
+       software distributed under the License is distributed on an
+       "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+       KIND, either express or implied.  See the License for the
+       specific language governing permissions and limitations
+       under the License.
+*/
+package org.apache.cordova.test;
+
+import org.apache.cordova.Whitelist;
+import org.apache.cordova.Config;
+
+import org.apache.cordova.CallbackContext;
+import org.apache.cordova.CordovaPlugin;
+import org.apache.cordova.PluginResult;
+import org.json.JSONArray;
+import org.json.JSONException;
+
+import org.apache.cordova.PluginManager;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+
+public class WhitelistAPI extends CordovaPlugin {
+    /**
+     * Executes the request and returns PluginResult.
+     *
+     * @param action            The action to execute.
+     * @param args              JSONArry of arguments for the plugin.
+     * @param callbackContext   The callback id used when calling back into JavaScript.
+     * @return                  True if the action was valid, false if not.
+     */
+    public boolean execute(String action, JSONArray args, CallbackContext callbackContext) throws JSONException {
+        if (action.equals("URLMatchesPatterns")) {
+            String url = args.getString(0);
+            JSONArray patterns = args.getJSONArray(1);
+            Whitelist whitelist = new Whitelist();
+            for (int i=0; i < patterns.length(); i++) {
+                String pattern = patterns.getString(i);
+                whitelist.addWhiteListEntry(pattern, false);
+            }
+            boolean isAllowed = whitelist.isUrlWhiteListed(url);
+            callbackContext.sendPluginResult(new PluginResult(PluginResult.Status.OK, isAllowed));
+            return true;
+        } else if (action.equals("URLIsAllowed")) {
+            String url = args.getString(0);
+            /* This code exists for compatibility between 3.x and 4.x versions of Cordova.
+             * Previously the CordovaWebView class had a method, getWhitelist, which would
+             * return a Whitelist object. Since the fixed whitelist is removed in Cordova 4.x,
+             * the correct call now is to shouldAllowRequest from the plugin manager.
+             */
+            Boolean isAllowed = null;
+            try {
+                Method isUrlWhiteListed = Config.class.getDeclaredMethod("isUrlWhitelisted", String.class);
+                isAllowed = (Boolean)isUrlWhiteListed.invoke(url);
+            } catch (NoSuchMethodException e) {
+            } catch (IllegalAccessException e) {
+            } catch (InvocationTargetException e) {
+            }
+            if (isAllowed == null) {
+                try {
+                    Method gpm = webView.getClass().getMethod("getPluginManager");
+                    PluginManager pm = (PluginManager)gpm.invoke(webView);
+                    Method isAllowedMethod = pm.getClass().getMethod("shouldAllowRequest", String.class);
+                    isAllowed = (Boolean)isAllowedMethod.invoke(pm, url);
+                    if (isAllowed == null) {
+                        isAllowed = false;
+                    }
+                } catch (NoSuchMethodException e) {
+                } catch (IllegalAccessException e) {
+                } catch (InvocationTargetException e) {
+                }
+            }
+
+            callbackContext.sendPluginResult(new PluginResult(PluginResult.Status.OK, isAllowed));
+            return true;
+        }
+        return false;
+    }
+}

package/demo/plugins/cordova-plugin-whitelist/tests/tests.js

@@ -0,0 +1,214 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ *
+ */
+
+exports.defineAutoTests = function () {
+
+    var isAndroid = (cordova.platformId === "android");
+
+    describe('Whitelist API (cordova.whitelist)', function () {
+
+        it("should exist", function () {
+            expect(cordova.whitelist).toBeDefined();
+        });
+
+        describe("Match function (cordova.whitelist.match) that checks URLs against patterns", function () {
+            function expectMatchWithResult(result) {
+                return (function (url, patterns, description) {
+                    description = description || ((result ? "should accept " : "should reject ") + url + " for " + JSON.stringify(patterns));
+                    this.result = result;
+
+                    describe("Match function", function () {
+                        if (!isAndroid) {
+                            pending("Whitelist Plugin only exists for Android");
+                        }
+
+                        // Timeout is 7.5 seconds to allow physical devices enough
+                        // time to query the response. This is important for some
+                        // Android devices.
+                        var originalTimeout,
+                            cb;
+
+                        beforeEach(function (done) {
+                            originalTimeout = jasmine.DEFAULT_TIMEOUT_INTERVAL;
+                            jasmine.DEFAULT_TIMEOUT_INTERVAL = 7500;
+                            
+                            cb = jasmine.createSpy('spy').and.callFake(function () {
+                                done();
+                            });
+                            cordova.whitelist.match(url, patterns, cb);
+                        });
+
+                        afterEach(function () {
+                            jasmine.DEFAULT_TIMEOUT_INTERVAL = originalTimeout;
+                        });
+
+                        it(description, function () {
+                            expect(cb).toHaveBeenCalledWith(result);
+                        });
+                    });
+                });
+            }
+
+            var itShouldMatch = expectMatchWithResult(true);
+            var itShouldNotMatch = expectMatchWithResult(false);
+
+            it("should exist", function () {
+                expect(cordova.whitelist.match).toBeDefined();
+                expect(typeof cordova.whitelist.match).toBe("function");
+            });
+
+            itShouldMatch('http://www.apache.org/',     ['*'],  "should accept any domain for *");
+            itShouldNotMatch('http://www.apache.org/',  [],     "should not accept any domain for []");
+
+            itShouldMatch('http://apache.org/',                                             ['http://*.apache.org']);
+            itShouldMatch('http://www.apache.org/',                                         ['http://*.apache.org']);
+            itShouldMatch('http://www.apache.org/some/path',                                ['http://*.apache.org']);
+            itShouldMatch('http://some.domain.under.apache.org/',                           ['http://*.apache.org']);
+            itShouldMatch('http://user:pass@apache.org/',                                   ['http://*.apache.org']);
+            itShouldMatch('http://user:pass@www.apache.org/',                               ['http://*.apache.org']);
+            itShouldMatch('http://www.apache.org/?some=params',                             ['http://*.apache.org']);
+            itShouldNotMatch('http://apache.com/',                                          ['http://*.apache.org']);
+            itShouldNotMatch('http://www.evil.com/?url=www.apache.org',                     ['http://*.apache.org']);
+            itShouldNotMatch('http://www.evil.com/?url=http://www.apache.org',              ['http://*.apache.org']);
+            itShouldNotMatch('http://www.evil.com/?url=http%3A%2F%2Fwww%2Eapache%2Eorg',    ['http://*.apache.org']);
+            itShouldNotMatch('https://apache.org/',                                         ['http://*.apache.org']);
+            itShouldNotMatch('http://www.apache.org:pass@evil.com/',                        ['http://*.apache.org']);
+            itShouldNotMatch('http://www.apache.org.evil.com/',                             ['http://*.apache.org']);
+
+            itShouldMatch('http://www.apache.org/',     ['http://*.apache.org', 'https://*.apache.org']);
+            itShouldMatch('https://www.apache.org/',    ['http://*.apache.org', 'https://*.apache.org']);
+            itShouldNotMatch('ftp://www.apache.org/',   ['http://*.apache.org', 'https://*.apache.org']);
+            itShouldNotMatch('http://www.apache.com/',  ['http://*.apache.org', 'https://*.apache.org']);
+
+            itShouldMatch('http://www.apache.org/',         ['http://www.apache.org']);
+            itShouldNotMatch('http://build.apache.org/',    ['http://www.apache.org']);
+            itShouldNotMatch('http://apache.org/',          ['http://www.apache.org']);
+
+            itShouldMatch('http://www.apache.org/',             ['http://*/*']);
+            itShouldMatch('http://www.apache.org/foo/bar.html', ['http://*/*']);
+
+            itShouldMatch('http://www.apache.org/foo',          ['http://*/foo*']);
+            itShouldMatch('http://www.apache.org/foo/bar.html', ['http://*/foo*']);
+            itShouldNotMatch('http://www.apache.org/',          ['http://*/foo*']);
+
+            itShouldMatch('file:///foo', ['file:///*']);
+
+            itShouldMatch('file:///foo',                ['file:///foo*']);
+            itShouldMatch('file:///foo/bar.html',       ['file:///foo*']);
+            itShouldNotMatch('file:///foo.html',        []);
+            itShouldNotMatch('http://www.apache.org/etc/foo',   ['http://www.apache.org/foo*']);
+            itShouldNotMatch('http://www.apache.org/foo',       ['file:///foo*']);
+
+            itShouldMatch('http://www.apache.org/',     ['*://www.apache.org/*']);
+            itShouldMatch('https://www.apache.org/',    ['*://www.apache.org/*']);
+            itShouldMatch('ftp://www.apache.org/',      ['*://www.apache.org/*']);
+            itShouldMatch('file://www.apache.org/',     ['*://www.apache.org/*']);
+            if (cordova.platformId == 'android')
+                itShouldMatch('content://www.apache.org/', ['*://www.apache.org/*']);
+            itShouldMatch('foo://www.apache.org/',      ['*://www.apache.org/*']);
+            itShouldNotMatch('http://www.apache.com/',  ['*://www.apache.org/*']);
+
+            itShouldMatch('http://www.apache.org/',     ['*.apache.org']);
+            itShouldMatch('https://www.apache.org/',    ['*.apache.org']);
+            itShouldNotMatch('ftp://www.apache.org/',   ['*.apache.org']);
+
+            itShouldMatch('http://www.apache.org:81/',                          ['http://www.apache.org:81/*']);
+            itShouldMatch('http://user:pass@www.apache.org:81/foo/bar.html',    ['http://www.apache.org:81/*']);
+            itShouldNotMatch('http://www.apache.org:80/',                       ['http://www.apache.org:81/*']);
+            itShouldNotMatch('http://www.apache.org/',                          ['http://www.apache.org:81/*']);
+            itShouldNotMatch('http://www.apache.org:foo/',                      ['http://www.apache.org:81/*']);
+            itShouldNotMatch('http://www.apache.org:81@www.apache.org/',        ['http://www.apache.org:81/*']);
+            itShouldNotMatch('http://www.apache.org:81@www.evil.com/',          ['http://www.apache.org:81/*']);
+
+            itShouldMatch('http://www.APAche.org/', ['*.apache.org']);
+            itShouldMatch('http://WWw.apache.org/', ['*.apache.org']);
+            itShouldMatch('http://www.apache.org/', ['*.APACHE.ORG']);
+            itShouldMatch('HTTP://www.apache.org/', ['*.apache.org']);
+            itShouldMatch('HTTP://www.apache.org/', ['http://*.apache.org']);
+            itShouldMatch('http://www.apache.org/', ['HTTP://*.apache.org']);
+
+            itShouldMatch('http://www.apache.org/foo/',         ['*://*.apache.org/foo/*']);
+            itShouldMatch('http://www.apache.org/foo/bar',      ['*://*.apache.org/foo/*']);
+            itShouldNotMatch('http://www.apache.org/bar/foo/',  ['*://*.apache.org/foo/*']);
+            itShouldNotMatch('http://www.apache.org/Foo/',      ['*://*.apache.org/foo/*']);
+            itShouldNotMatch('http://www.apache.org/Foo/bar',   ['*://*.apache.org/foo/*']);
+        });
+
+        describe("Test function (cordova.whitelist.test) that checks against config.xml", function () {
+            function expectTestWithResult(result) {
+                return (function (url, description) {
+                    description = description || ((result ? "should accept " : "should reject ") + url);
+
+                    describe("Test function", function () {
+                        if (!isAndroid) {
+                            pending("Whitelist Plugin only exists for Android");
+                        }
+
+                        var cb,
+                            originalTimeout;
+
+                        beforeEach(function (done) {
+                            originalTimeout = jasmine.DEFAULT_TIMEOUT_INTERVAL;
+                            jasmine.DEFAULT_TIMEOUT_INTERVAL = 7500;
+                            cb = jasmine.createSpy('spy').and.callFake(function (){
+                                done();
+                            });
+                            cordova.whitelist.test(url, cb);
+                        });
+
+                        afterEach(function () {
+                            jasmine.DEFAULT_TIMEOUT_INTERVAL = originalTimeout;
+                        });
+
+                        it(description, function () {
+                            expect(cb).toHaveBeenCalledWith(result);
+                        });
+                    });
+                });
+            }
+
+            var itShouldAccept = expectTestWithResult(true);
+            var itShouldReject = expectTestWithResult(false);
+
+            it("should exist", function () {
+                expect(cordova.whitelist.test).toBeDefined();
+                expect(typeof cordova.whitelist.test).toBe("function");
+            });
+
+            itShouldAccept('http://apache.org');
+            itShouldAccept('http://apache.org/');
+            itShouldAccept('http://www.apache.org/');
+            itShouldAccept('http://www.apache.org/some/path');
+            itShouldAccept('http://some.domain.under.apache.org/');
+            itShouldAccept('http://user:pass@apache.org/');
+            itShouldAccept('http://user:pass@www.apache.org/');
+            itShouldAccept('https://www.apache.org/');
+
+            itShouldReject('ftp://www.apache.org/');
+            itShouldReject('http://www.apache.com/');
+            itShouldReject('http://www.apache.org:pass@evil.com/');
+            itShouldReject('http://www.apache.org.evil.com/');
+
+            itShouldAccept('file:///foo');
+            if (cordova.platformId == 'android')
+                itShouldReject('content:///foo');
+        });
+    });
+}

package/demo/plugins/cordova-plugin-wkwebview-engine/CONTRIBUTING.md

@@ -0,0 +1,32 @@
+<!--
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+#  KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+-->
+
+# Contributing to Apache Cordova
+
+Anyone can contribute to Cordova. And we need your contributions.
+
+There are multiple ways to contribute: report bugs, improve the docs, and
+contribute code.
+
+For instructions on this, start with the 
+[contribution overview](http://cordova.apache.org/contribute/).
+
+We look forward to your contributions!