diff --git a/tools/test/scenarios/archetypes.xml b/tools/test/scenarios/archetypes.xml
index 1dc3b41..17faab3 100644
--- a/tools/test/scenarios/archetypes.xml
+++ b/tools/test/scenarios/archetypes.xml
@@ -1,5 +1,5 @@
 <!--
-  ~ Copyright 2015-present Open Networking Laboratory
+  ~ Copyright 2015-present Open Networking Foundation
   ~
   ~ Licensed under the Apache License, Version 2.0 (the "License");
   ~ you may not use this file except in compliance with the License.
diff --git a/tools/test/scenarios/dist-counter.xml b/tools/test/scenarios/dist-counter.xml
index 64ce7d5..425650f 100644
--- a/tools/test/scenarios/dist-counter.xml
+++ b/tools/test/scenarios/dist-counter.xml
@@ -1,5 +1,5 @@
 <!--
-  ~ Copyright 2016-present Open Networking Laboratory
+  ~ Copyright 2016-present Open Networking Foundation
   ~
   ~ Licensed under the Apache License, Version 2.0 (the "License");
   ~ you may not use this file except in compliance with the License.
diff --git a/tools/test/scenarios/dist-ec-map.xml b/tools/test/scenarios/dist-ec-map.xml
index 7a2d844..0919542 100644
--- a/tools/test/scenarios/dist-ec-map.xml
+++ b/tools/test/scenarios/dist-ec-map.xml
@@ -1,5 +1,5 @@
 <!--
-  ~ Copyright 2017-present Open Networking Laboratory
+  ~ Copyright 2017-present Open Networking Foundation
   ~
   ~ Licensed under the Apache License, Version 2.0 (the "License");
   ~ you may not use this file except in compliance with the License.
diff --git a/tools/test/scenarios/dist-leader.xml b/tools/test/scenarios/dist-leader.xml
index 1c63dfd..51c2492 100644
--- a/tools/test/scenarios/dist-leader.xml
+++ b/tools/test/scenarios/dist-leader.xml
@@ -1,5 +1,5 @@
 <!--
-  ~ Copyright 2016-present Open Networking Laboratory
+  ~ Copyright 2016-present Open Networking Foundation
   ~
   ~ Licensed under the Apache License, Version 2.0 (the "License");
   ~ you may not use this file except in compliance with the License.
diff --git a/tools/test/scenarios/dist-map.xml b/tools/test/scenarios/dist-map.xml
index 196f061..58c15c2 100644
--- a/tools/test/scenarios/dist-map.xml
+++ b/tools/test/scenarios/dist-map.xml
@@ -1,5 +1,5 @@
 <!--
-  ~ Copyright 2016-present Open Networking Laboratory
+  ~ Copyright 2016-present Open Networking Foundation
   ~
   ~ Licensed under the Apache License, Version 2.0 (the "License");
   ~ you may not use this file except in compliance with the License.
diff --git a/tools/test/scenarios/dist-setup.xml b/tools/test/scenarios/dist-setup.xml
index 7b35087..85bce01 100644
--- a/tools/test/scenarios/dist-setup.xml
+++ b/tools/test/scenarios/dist-setup.xml
@@ -1,5 +1,5 @@
 <!--
-  ~ Copyright 2015-present Open Networking Laboratory
+  ~ Copyright 2015-present Open Networking Foundation
   ~
   ~ Licensed under the Apache License, Version 2.0 (the "License");
   ~ you may not use this file except in compliance with the License.
diff --git a/tools/test/scenarios/dist-teardown.xml b/tools/test/scenarios/dist-teardown.xml
index b22df00..ffe3b19 100644
--- a/tools/test/scenarios/dist-teardown.xml
+++ b/tools/test/scenarios/dist-teardown.xml
@@ -1,5 +1,5 @@
 <!--
-  ~ Copyright 2015-present Open Networking Laboratory
+  ~ Copyright 2015-present Open Networking Foundation
   ~
   ~ Licensed under the Apache License, Version 2.0 (the "License");
   ~ you may not use this file except in compliance with the License.
diff --git a/tools/test/scenarios/dist-test-seq.xml b/tools/test/scenarios/dist-test-seq.xml
index 15627d1..086b749 100644
--- a/tools/test/scenarios/dist-test-seq.xml
+++ b/tools/test/scenarios/dist-test-seq.xml
@@ -1,5 +1,5 @@
 <!--
-  ~ Copyright 2015-present Open Networking Laboratory
+  ~ Copyright 2015-present Open Networking Foundation
   ~
   ~ Licensed under the Apache License, Version 2.0 (the "License");
   ~ you may not use this file except in compliance with the License.
diff --git a/tools/test/scenarios/dist-test.xml b/tools/test/scenarios/dist-test.xml
index 9cae5dc..9f1e6d4 100644
--- a/tools/test/scenarios/dist-test.xml
+++ b/tools/test/scenarios/dist-test.xml
@@ -1,5 +1,5 @@
 <!--
-  ~ Copyright 2015-present Open Networking Laboratory
+  ~ Copyright 2015-present Open Networking Foundation
   ~
   ~ Licensed under the Apache License, Version 2.0 (the "License");
   ~ you may not use this file except in compliance with the License.
diff --git a/tools/test/scenarios/dist-value.xml b/tools/test/scenarios/dist-value.xml
index cda15cd..3ee1a5a 100644
--- a/tools/test/scenarios/dist-value.xml
+++ b/tools/test/scenarios/dist-value.xml
@@ -1,5 +1,5 @@
 <!--
-  ~ Copyright 2016-present Open Networking Laboratory
+  ~ Copyright 2016-present Open Networking Foundation
   ~
   ~ Licensed under the Apache License, Version 2.0 (the "License");
   ~ you may not use this file except in compliance with the License.
diff --git a/tools/test/scenarios/dist-work-queue.xml b/tools/test/scenarios/dist-work-queue.xml
index 7a9b414..28836fe 100644
--- a/tools/test/scenarios/dist-work-queue.xml
+++ b/tools/test/scenarios/dist-work-queue.xml
@@ -1,5 +1,5 @@
 <!--
-  ~ Copyright 2016-present Open Networking Laboratory
+  ~ Copyright 2016-present Open Networking Foundation
   ~
   ~ Licensed under the Apache License, Version 2.0 (the "License");
   ~ you may not use this file except in compliance with the License.
diff --git a/tools/test/scenarios/drivers-test.xml b/tools/test/scenarios/drivers-test.xml
index 7bc2bba..a571093 100644
--- a/tools/test/scenarios/drivers-test.xml
+++ b/tools/test/scenarios/drivers-test.xml
@@ -1,5 +1,5 @@
 <!--
-  ~ Copyright 2016-present Open Networking Laboratory
+  ~ Copyright 2016-present Open Networking Foundation
   ~
   ~ Licensed under the Apache License, Version 2.0 (the "License");
   ~ you may not use this file except in compliance with the License.
diff --git a/tools/test/scenarios/example.xml b/tools/test/scenarios/example.xml
index 1c4c360..080af07 100644
--- a/tools/test/scenarios/example.xml
+++ b/tools/test/scenarios/example.xml
@@ -1,5 +1,5 @@
 <!--
-  ~ Copyright 2015-present Open Networking Laboratory
+  ~ Copyright 2015-present Open Networking Foundation
   ~
   ~ Licensed under the Apache License, Version 2.0 (the "License");
   ~ you may not use this file except in compliance with the License.
diff --git a/tools/test/scenarios/fast.xml b/tools/test/scenarios/fast.xml
index b488e60..6786f05 100644
--- a/tools/test/scenarios/fast.xml
+++ b/tools/test/scenarios/fast.xml
@@ -1,5 +1,5 @@
 <!--
-  ~ Copyright 2015-present Open Networking Laboratory
+  ~ Copyright 2015-present Open Networking Foundation
   ~
   ~ Licensed under the Apache License, Version 2.0 (the "License");
   ~ you may not use this file except in compliance with the License.
diff --git a/tools/test/scenarios/ha-cluster-restart.xml b/tools/test/scenarios/ha-cluster-restart.xml
index 8f02f63..fa20c61 100644
--- a/tools/test/scenarios/ha-cluster-restart.xml
+++ b/tools/test/scenarios/ha-cluster-restart.xml
@@ -1,5 +1,5 @@
 <!--
-  ~ Copyright 2016-present Open Networking Laboratory
+  ~ Copyright 2016-present Open Networking Foundation
   ~
   ~ Licensed under the Apache License, Version 2.0 (the "License");
   ~ you may not use this file except in compliance with the License.
diff --git a/tools/test/scenarios/ha-single-node.xml b/tools/test/scenarios/ha-single-node.xml
index f1b17ee..bf69e96 100644
--- a/tools/test/scenarios/ha-single-node.xml
+++ b/tools/test/scenarios/ha-single-node.xml
@@ -1,5 +1,5 @@
 <!--
-  ~ Copyright 2016-present Open Networking Laboratory
+  ~ Copyright 2016-present Open Networking Foundation
   ~
   ~ Licensed under the Apache License, Version 2.0 (the "License");
   ~ you may not use this file except in compliance with the License.
diff --git a/tools/test/scenarios/kill.xml b/tools/test/scenarios/kill.xml
index b798684..d5836ac 100644
--- a/tools/test/scenarios/kill.xml
+++ b/tools/test/scenarios/kill.xml
@@ -1,5 +1,5 @@
 <!--
-  ~ Copyright 2016-present Open Networking Laboratory
+  ~ Copyright 2016-present Open Networking Foundation
   ~
   ~ Licensed under the Apache License, Version 2.0 (the "License");
   ~ you may not use this file except in compliance with the License.
diff --git a/tools/test/scenarios/layout-basic.xml b/tools/test/scenarios/layout-basic.xml
index 01b763b..ad54085 100644
--- a/tools/test/scenarios/layout-basic.xml
+++ b/tools/test/scenarios/layout-basic.xml
@@ -1,5 +1,5 @@
 <!--
-  ~ Copyright 2016-present Open Networking Laboratory
+  ~ Copyright 2016-present Open Networking Foundation
   ~
   ~ Licensed under the Apache License, Version 2.0 (the "License");
   ~ you may not use this file except in compliance with the License.
diff --git a/tools/test/scenarios/log-mark.xml b/tools/test/scenarios/log-mark.xml
index 384a8468..28aefbf 100644
--- a/tools/test/scenarios/log-mark.xml
+++ b/tools/test/scenarios/log-mark.xml
@@ -1,5 +1,5 @@
 <!--
-  ~ Copyright 2017-present Open Networking Laboratory
+  ~ Copyright 2017-present Open Networking Foundation
   ~
   ~ Licensed under the Apache License, Version 2.0 (the "License");
   ~ you may not use this file except in compliance with the License.
diff --git a/tools/test/scenarios/maps-cli.xml b/tools/test/scenarios/maps-cli.xml
index a76bd1a..bc2229e 100644
--- a/tools/test/scenarios/maps-cli.xml
+++ b/tools/test/scenarios/maps-cli.xml
@@ -1,5 +1,5 @@
 <!--
-  ~ Copyright 2017-present Open Networking Laboratory
+  ~ Copyright 2017-present Open Networking Foundation
   ~
   ~ Licensed under the Apache License, Version 2.0 (the "License");
   ~ you may not use this file except in compliance with the License.
diff --git a/tools/test/scenarios/meta-apps-test.xml b/tools/test/scenarios/meta-apps-test.xml
index 4338dd3..f405ded 100644
--- a/tools/test/scenarios/meta-apps-test.xml
+++ b/tools/test/scenarios/meta-apps-test.xml
@@ -1,5 +1,5 @@
 <!--
-  ~ Copyright 2016-present Open Networking Laboratory
+  ~ Copyright 2016-present Open Networking Foundation
   ~
   ~ Licensed under the Apache License, Version 2.0 (the "License");
   ~ you may not use this file except in compliance with the License.
diff --git a/tools/test/scenarios/net-activate-fwd.xml b/tools/test/scenarios/net-activate-fwd.xml
index 8114b5e..bad7e22 100644
--- a/tools/test/scenarios/net-activate-fwd.xml
+++ b/tools/test/scenarios/net-activate-fwd.xml
@@ -1,5 +1,5 @@
 <!--
-  ~ Copyright 2016-present Open Networking Laboratory
+  ~ Copyright 2016-present Open Networking Foundation
   ~
   ~ Licensed under the Apache License, Version 2.0 (the "License");
   ~ you may not use this file except in compliance with the License.
diff --git a/tools/test/scenarios/net-create-flows.xml b/tools/test/scenarios/net-create-flows.xml
index b0e2782..5e8e457 100644
--- a/tools/test/scenarios/net-create-flows.xml
+++ b/tools/test/scenarios/net-create-flows.xml
@@ -1,5 +1,5 @@
 <!--
-  ~ Copyright 2015-present Open Networking Laboratory
+  ~ Copyright 2015-present Open Networking Foundation
   ~
   ~ Licensed under the Apache License, Version 2.0 (the "License");
   ~ you may not use this file except in compliance with the License.
diff --git a/tools/test/scenarios/net-deactivate-fwd.xml b/tools/test/scenarios/net-deactivate-fwd.xml
index dccb9ab..e2daae5 100644
--- a/tools/test/scenarios/net-deactivate-fwd.xml
+++ b/tools/test/scenarios/net-deactivate-fwd.xml
@@ -1,5 +1,5 @@
 <!--
-  ~ Copyright 2016-present Open Networking Laboratory
+  ~ Copyright 2016-present Open Networking Foundation
   ~
   ~ Licensed under the Apache License, Version 2.0 (the "License");
   ~ you may not use this file except in compliance with the License.
diff --git a/tools/test/scenarios/net-fast.xml b/tools/test/scenarios/net-fast.xml
index 12b5097..e7804e0 100644
--- a/tools/test/scenarios/net-fast.xml
+++ b/tools/test/scenarios/net-fast.xml
@@ -1,5 +1,5 @@
 <!--
-  ~ Copyright 2015-present Open Networking Laboratory
+  ~ Copyright 2015-present Open Networking Foundation
   ~
   ~ Licensed under the Apache License, Version 2.0 (the "License");
   ~ you may not use this file except in compliance with the License.
diff --git a/tools/test/scenarios/net-flow-objectives.xml b/tools/test/scenarios/net-flow-objectives.xml
index 1f92ab8..5b7535c 100644
--- a/tools/test/scenarios/net-flow-objectives.xml
+++ b/tools/test/scenarios/net-flow-objectives.xml
@@ -1,5 +1,5 @@
 <!--
-  ~ Copyright 2016-present Open Networking Laboratory
+  ~ Copyright 2016-present Open Networking Foundation
   ~
   ~ Licensed under the Apache License, Version 2.0 (the "License");
   ~ you may not use this file except in compliance with the License.
diff --git a/tools/test/scenarios/net-host-intent.xml b/tools/test/scenarios/net-host-intent.xml
index d4f7a0b..b11f663 100644
--- a/tools/test/scenarios/net-host-intent.xml
+++ b/tools/test/scenarios/net-host-intent.xml
@@ -1,5 +1,5 @@
 <!--
-  ~ Copyright 2015-present Open Networking Laboratory
+  ~ Copyright 2015-present Open Networking Foundation
   ~
   ~ Licensed under the Apache License, Version 2.0 (the "License");
   ~ you may not use this file except in compliance with the License.
diff --git a/tools/test/scenarios/net-link-down-up.xml b/tools/test/scenarios/net-link-down-up.xml
index 07398ec..551db08 100644
--- a/tools/test/scenarios/net-link-down-up.xml
+++ b/tools/test/scenarios/net-link-down-up.xml
@@ -1,5 +1,5 @@
 <!--
-  ~ Copyright 2015-present Open Networking Laboratory
+  ~ Copyright 2015-present Open Networking Foundation
   ~
   ~ Licensed under the Apache License, Version 2.0 (the "License");
   ~ you may not use this file except in compliance with the License.
diff --git a/tools/test/scenarios/net-multi-to-single-intent.xml b/tools/test/scenarios/net-multi-to-single-intent.xml
index ef23ea8..4ce8003 100644
--- a/tools/test/scenarios/net-multi-to-single-intent.xml
+++ b/tools/test/scenarios/net-multi-to-single-intent.xml
@@ -1,5 +1,5 @@
 <!--
-  ~ Copyright 2016-present Open Networking Laboratory
+  ~ Copyright 2016-present Open Networking Foundation
   ~
   ~ Licensed under the Apache License, Version 2.0 (the "License");
   ~ you may not use this file except in compliance with the License.
diff --git a/tools/test/scenarios/net-pingall.xml b/tools/test/scenarios/net-pingall.xml
index b97d843..ef31aae 100644
--- a/tools/test/scenarios/net-pingall.xml
+++ b/tools/test/scenarios/net-pingall.xml
@@ -1,5 +1,5 @@
 <!--
-  ~ Copyright 2015-present Open Networking Laboratory
+  ~ Copyright 2015-present Open Networking Foundation
   ~
   ~ Licensed under the Apache License, Version 2.0 (the "License");
   ~ you may not use this file except in compliance with the License.
diff --git a/tools/test/scenarios/net-point-intent.xml b/tools/test/scenarios/net-point-intent.xml
index 3800f43..3d2cee7 100644
--- a/tools/test/scenarios/net-point-intent.xml
+++ b/tools/test/scenarios/net-point-intent.xml
@@ -1,5 +1,5 @@
 <!--
-  ~ Copyright 2015-present Open Networking Laboratory
+  ~ Copyright 2015-present Open Networking Foundation
   ~
   ~ Licensed under the Apache License, Version 2.0 (the "License");
   ~ you may not use this file except in compliance with the License.
diff --git a/tools/test/scenarios/net-prerequisites.xml b/tools/test/scenarios/net-prerequisites.xml
index e4c5ea5..ec2cd3b 100644
--- a/tools/test/scenarios/net-prerequisites.xml
+++ b/tools/test/scenarios/net-prerequisites.xml
@@ -1,5 +1,5 @@
 <!--
-  ~ Copyright 2016-present Open Networking Laboratory
+  ~ Copyright 2016-present Open Networking Foundation
   ~
   ~ Licensed under the Apache License, Version 2.0 (the "License");
   ~ you may not use this file except in compliance with the License.
diff --git a/tools/test/scenarios/net-reactive-fwd.xml b/tools/test/scenarios/net-reactive-fwd.xml
index fe439b7..b3968dc 100644
--- a/tools/test/scenarios/net-reactive-fwd.xml
+++ b/tools/test/scenarios/net-reactive-fwd.xml
@@ -1,5 +1,5 @@
 <!--
-  ~ Copyright 2016-present Open Networking Laboratory
+  ~ Copyright 2016-present Open Networking Foundation
   ~
   ~ Licensed under the Apache License, Version 2.0 (the "License");
   ~ you may not use this file except in compliance with the License.
diff --git a/tools/test/scenarios/net-rest.xml b/tools/test/scenarios/net-rest.xml
index 78eacd2..7b5a4c8 100644
--- a/tools/test/scenarios/net-rest.xml
+++ b/tools/test/scenarios/net-rest.xml
@@ -1,5 +1,5 @@
 <!--
-  ~ Copyright 2015-present Open Networking Laboratory
+  ~ Copyright 2015-present Open Networking Foundation
   ~
   ~ Licensed under the Apache License, Version 2.0 (the "License");
   ~ you may not use this file except in compliance with the License.
diff --git a/tools/test/scenarios/net-setup-vnets.xml b/tools/test/scenarios/net-setup-vnets.xml
index bd58036..cc9e39c 100644
--- a/tools/test/scenarios/net-setup-vnets.xml
+++ b/tools/test/scenarios/net-setup-vnets.xml
@@ -1,5 +1,5 @@
 <!--
-  ~  Copyright 2016-present Open Networking Laboratory
+  ~  Copyright 2016-present Open Networking Foundation
   ~
   ~  Licensed under the Apache License, Version 2.0 (the "License");
   ~  you may not use this file except in compliance with the License.
diff --git a/tools/test/scenarios/net-setup.xml b/tools/test/scenarios/net-setup.xml
index 5376783..52ae059 100644
--- a/tools/test/scenarios/net-setup.xml
+++ b/tools/test/scenarios/net-setup.xml
@@ -1,5 +1,5 @@
 <!--
-  ~ Copyright 2015-present Open Networking Laboratory
+  ~ Copyright 2015-present Open Networking Foundation
   ~
   ~ Licensed under the Apache License, Version 2.0 (the "License");
   ~ you may not use this file except in compliance with the License.
diff --git a/tools/test/scenarios/net-single-to-multi-intent.xml b/tools/test/scenarios/net-single-to-multi-intent.xml
index d132d8d..e7fea6a 100644
--- a/tools/test/scenarios/net-single-to-multi-intent.xml
+++ b/tools/test/scenarios/net-single-to-multi-intent.xml
@@ -1,5 +1,5 @@
 <!--
-  ~ Copyright 2016-present Open Networking Laboratory
+  ~ Copyright 2016-present Open Networking Foundation
   ~
   ~ Licensed under the Apache License, Version 2.0 (the "License");
   ~ you may not use this file except in compliance with the License.
diff --git a/tools/test/scenarios/net-smoke.xml b/tools/test/scenarios/net-smoke.xml
index 50653fc..fdbde18 100644
--- a/tools/test/scenarios/net-smoke.xml
+++ b/tools/test/scenarios/net-smoke.xml
@@ -1,5 +1,5 @@
 <!--
-  ~ Copyright 2015-present Open Networking Laboratory
+  ~ Copyright 2015-present Open Networking Foundation
   ~
   ~ Licensed under the Apache License, Version 2.0 (the "License");
   ~ you may not use this file except in compliance with the License.
diff --git a/tools/test/scenarios/net-teardown-vnets.xml b/tools/test/scenarios/net-teardown-vnets.xml
index fe19c33..add862e 100644
--- a/tools/test/scenarios/net-teardown-vnets.xml
+++ b/tools/test/scenarios/net-teardown-vnets.xml
@@ -1,5 +1,5 @@
 <!--
-  ~  Copyright 2016-present Open Networking Laboratory
+  ~  Copyright 2016-present Open Networking Foundation
   ~
   ~  Licensed under the Apache License, Version 2.0 (the "License");
   ~  you may not use this file except in compliance with the License.
diff --git a/tools/test/scenarios/net-teardown.xml b/tools/test/scenarios/net-teardown.xml
index 829e917..9b4c309 100644
--- a/tools/test/scenarios/net-teardown.xml
+++ b/tools/test/scenarios/net-teardown.xml
@@ -1,5 +1,5 @@
 <!--
-  ~ Copyright 2015-present Open Networking Laboratory
+  ~ Copyright 2015-present Open Networking Foundation
   ~
   ~ Licensed under the Apache License, Version 2.0 (the "License");
   ~ you may not use this file except in compliance with the License.
diff --git a/tools/test/scenarios/net-topo.xml b/tools/test/scenarios/net-topo.xml
index f13543f..1a832ad 100644
--- a/tools/test/scenarios/net-topo.xml
+++ b/tools/test/scenarios/net-topo.xml
@@ -1,5 +1,5 @@
 <!--
-  ~ Copyright 2015-present Open Networking Laboratory
+  ~ Copyright 2015-present Open Networking Foundation
   ~
   ~ Licensed under the Apache License, Version 2.0 (the "License");
   ~ you may not use this file except in compliance with the License.
diff --git a/tools/test/scenarios/netcfg.xml b/tools/test/scenarios/netcfg.xml
index 40e1165..cfea399 100644
--- a/tools/test/scenarios/netcfg.xml
+++ b/tools/test/scenarios/netcfg.xml
@@ -1,5 +1,5 @@
 <!--
-  ~ Copyright 2016-present Open Networking Laboratory
+  ~ Copyright 2016-present Open Networking Foundation
   ~
   ~ Licensed under the Apache License, Version 2.0 (the "License");
   ~ you may not use this file except in compliance with the License.
diff --git a/tools/test/scenarios/prerequisites.xml b/tools/test/scenarios/prerequisites.xml
index e9dcc29..aa396c8 100644
--- a/tools/test/scenarios/prerequisites.xml
+++ b/tools/test/scenarios/prerequisites.xml
@@ -1,5 +1,5 @@
 <!--
-  ~ Copyright 2015-present Open Networking Laboratory
+  ~ Copyright 2015-present Open Networking Foundation
   ~
   ~ Licensed under the Apache License, Version 2.0 (the "License");
   ~ you may not use this file except in compliance with the License.
diff --git a/tools/test/scenarios/restart.xml b/tools/test/scenarios/restart.xml
index 7751157..9da9c9b 100644
--- a/tools/test/scenarios/restart.xml
+++ b/tools/test/scenarios/restart.xml
@@ -1,5 +1,5 @@
 <!--
-  ~ Copyright 2016-present Open Networking Laboratory
+  ~ Copyright 2016-present Open Networking Foundation
   ~
   ~ Licensed under the Apache License, Version 2.0 (the "License");
   ~ you may not use this file except in compliance with the License.
diff --git a/tools/test/scenarios/sequential-example.xml b/tools/test/scenarios/sequential-example.xml
index ab97388..af1342c 100644
--- a/tools/test/scenarios/sequential-example.xml
+++ b/tools/test/scenarios/sequential-example.xml
@@ -1,5 +1,5 @@
 <!--
-  ~ Copyright 2015-present Open Networking Laboratory
+  ~ Copyright 2015-present Open Networking Foundation
   ~
   ~ Licensed under the Apache License, Version 2.0 (the "License");
   ~ you may not use this file except in compliance with the License.
diff --git a/tools/test/scenarios/setup.xml b/tools/test/scenarios/setup.xml
index 1d1c36a..e87996d 100644
--- a/tools/test/scenarios/setup.xml
+++ b/tools/test/scenarios/setup.xml
@@ -1,5 +1,5 @@
 <!--
-  ~ Copyright 2015-present Open Networking Laboratory
+  ~ Copyright 2015-present Open Networking Foundation
   ~
   ~ Licensed under the Apache License, Version 2.0 (the "License");
   ~ you may not use this file except in compliance with the License.
diff --git a/tools/test/scenarios/shutdown.xml b/tools/test/scenarios/shutdown.xml
index 935145e..6063c53 100644
--- a/tools/test/scenarios/shutdown.xml
+++ b/tools/test/scenarios/shutdown.xml
@@ -1,5 +1,5 @@
 <!--
-  ~ Copyright 2015-present Open Networking Laboratory
+  ~ Copyright 2015-present Open Networking Foundation
   ~
   ~ Licensed under the Apache License, Version 2.0 (the "License");
   ~ you may not use this file except in compliance with the License.
diff --git a/tools/test/scenarios/smoke-internal.xml b/tools/test/scenarios/smoke-internal.xml
index 68eafed..a9fe3ab 100644
--- a/tools/test/scenarios/smoke-internal.xml
+++ b/tools/test/scenarios/smoke-internal.xml
@@ -1,5 +1,5 @@
 <!--
-  ~ Copyright 2016-present Open Networking Laboratory
+  ~ Copyright 2016-present Open Networking Foundation
   ~
   ~ Licensed under the Apache License, Version 2.0 (the "License");
   ~ you may not use this file except in compliance with the License.
diff --git a/tools/test/scenarios/smoke.xml b/tools/test/scenarios/smoke.xml
index 5b95e70..8c278f3 100644
--- a/tools/test/scenarios/smoke.xml
+++ b/tools/test/scenarios/smoke.xml
@@ -1,5 +1,5 @@
 <!--
-  ~ Copyright 2015-present Open Networking Laboratory
+  ~ Copyright 2015-present Open Networking Foundation
   ~
   ~ Licensed under the Apache License, Version 2.0 (the "License");
   ~ you may not use this file except in compliance with the License.
diff --git a/tools/test/scenarios/startup.xml b/tools/test/scenarios/startup.xml
index 27c324f..e86c02a 100644
--- a/tools/test/scenarios/startup.xml
+++ b/tools/test/scenarios/startup.xml
@@ -1,5 +1,5 @@
 <!--
-  ~ Copyright 2015-present Open Networking Laboratory
+  ~ Copyright 2015-present Open Networking Foundation
   ~
   ~ Licensed under the Apache License, Version 2.0 (the "License");
   ~ you may not use this file except in compliance with the License.
diff --git a/tools/test/scenarios/tar-setup.xml b/tools/test/scenarios/tar-setup.xml
index c6e8201..f51a0e0 100644
--- a/tools/test/scenarios/tar-setup.xml
+++ b/tools/test/scenarios/tar-setup.xml
@@ -1,5 +1,5 @@
 <!--
-  ~ Copyright 2015-present Open Networking Laboratory
+  ~ Copyright 2015-present Open Networking Foundation
   ~
   ~ Licensed under the Apache License, Version 2.0 (the "License");
   ~ you may not use this file except in compliance with the License.
diff --git a/tools/test/scenarios/teardown.xml b/tools/test/scenarios/teardown.xml
index 77a24c5..3199d25 100644
--- a/tools/test/scenarios/teardown.xml
+++ b/tools/test/scenarios/teardown.xml
@@ -1,5 +1,5 @@
 <!--
-  ~ Copyright 2016-present Open Networking Laboratory
+  ~ Copyright 2016-present Open Networking Foundation
   ~
   ~ Licensed under the Apache License, Version 2.0 (the "License");
   ~ you may not use this file except in compliance with the License.
diff --git a/tools/test/scenarios/vnets.xml b/tools/test/scenarios/vnets.xml
index 57ec4ef..fa29445 100644
--- a/tools/test/scenarios/vnets.xml
+++ b/tools/test/scenarios/vnets.xml
@@ -1,5 +1,5 @@
 <!--
-  ~ Copyright 2016-present Open Networking Laboratory
+  ~ Copyright 2016-present Open Networking Foundation
   ~
   ~ Licensed under the Apache License, Version 2.0 (the "License");
   ~ you may not use this file except in compliance with the License.
diff --git a/tools/test/scenarios/wrapup.xml b/tools/test/scenarios/wrapup.xml
index 99345e0..b6fe489 100644
--- a/tools/test/scenarios/wrapup.xml
+++ b/tools/test/scenarios/wrapup.xml
@@ -1,5 +1,5 @@
 <!--
-  ~ Copyright 2015-present Open Networking Laboratory
+  ~ Copyright 2015-present Open Networking Foundation
   ~
   ~ Licensed under the Apache License, Version 2.0 (the "License");
   ~ you may not use this file except in compliance with the License.
diff --git a/tools/test/scenarios/yang-smoke.xml b/tools/test/scenarios/yang-smoke.xml
index b44646d..ac9b86b 100644
--- a/tools/test/scenarios/yang-smoke.xml
+++ b/tools/test/scenarios/yang-smoke.xml
@@ -1,5 +1,5 @@
 <!--
-  ~ Copyright 2017-present Open Networking Laboratory
+  ~ Copyright 2017-present Open Networking Foundation
   ~
   ~ Licensed under the Apache License, Version 2.0 (the "License");
   ~ you may not use this file except in compliance with the License.
