tests/src/system/basic/WskActionTests.scala - openwhisk-runtime-java - Git at Google

 /*
  * Copyright 2015-2016 IBM Corporation
  *
  * Licensed 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 system.basic

 import org.junit.runner.RunWith
 import org.scalatest.junit.JUnitRunner

 import common.JsHelpers
 import common.TestHelpers
 import common.TestUtils
 import common.Wsk
 import common.WskProps
 import common.WskTestHelpers
 import spray.json._
 import spray.json.DefaultJsonProtocol._
 import spray.json.JsObject
 import spray.json.pimpAny

 @RunWith(classOf[JUnitRunner])
 class WskActionTests
     extends TestHelpers
     with WskTestHelpers
     with JsHelpers {

     implicit val wskprops = WskProps()
     val wsk = new Wsk

     val testString = "this is a test"
     val testResult = JsObject("count" -> testString.split(" ").length.toJson)
     val guestNamespace = wskprops.namespace

     behavior of "Whisk actions"

     it should "invoke an action returning a promise" in withAssetCleaner(wskprops) {
         (wp, assetHelper) =>
             val name = "hello promise"
             assetHelper.withCleaner(wsk.action, name) {
                 (action, _) => action.create(name, Some(TestUtils.getTestActionFilename("helloPromise.js")))
             }

             val run = wsk.action.invoke(name)
             withActivation(wsk.activation, run) {
                 activation =>
                     activation.response.status shouldBe "success"
                     activation.response.result shouldBe Some(JsObject("done" -> true.toJson))
                     activation.logs.get.mkString(" ") shouldBe empty
             }
     }

     it should "invoke an action with a space in the name" in withAssetCleaner(wskprops) {
         (wp, assetHelper) =>
             val name = "hello Async"
             assetHelper.withCleaner(wsk.action, name) {
                 (action, _) => action.create(name, Some(TestUtils.getTestActionFilename("helloAsync.js")))
             }

             val run = wsk.action.invoke(name, Map("payload" -> testString.toJson))
             withActivation(wsk.activation, run) {
                 activation =>
                     activation.response.status shouldBe "success"
                     activation.response.result shouldBe Some(testResult)
                     activation.logs.get.mkString(" ") should include(testString)
             }
     }

     it should "pass parameters bound on creation-time to the action" in withAssetCleaner(wskprops) {
         (wp, assetHelper) =>
             val name = "printParams"
             val params = Map(
                 "param1" -> "test1",
                 "param2" -> "test2")

             assetHelper.withCleaner(wsk.action, name) {
                 (action, _) =>
                     action.create(
                         name,
                         Some(TestUtils.getTestActionFilename("printParams.js")),
                         parameters = params.mapValues(_.toJson))
             }

             val invokeParams = Map("payload" -> testString)
             val run = wsk.action.invoke(name, invokeParams.mapValues(_.toJson))
             withActivation(wsk.activation, run) {
                 activation =>
                     val logs = activation.logs.get.mkString(" ")

                     (params ++ invokeParams).foreach {
                         case (key, value) =>
                             logs should include(s"params.$key: $value")
                     }
             }
     }

     it should "copy an action and invoke it successfully" in withAssetCleaner(wskprops) {
         (wp, assetHelper) =>
             val name = "copied"
             val packageName = "samples"
             val actionName = "wordcount"
             val fullQualifiedName = s"/$guestNamespace/$packageName/$actionName"

             assetHelper.withCleaner(wsk.pkg, packageName) {
                 (pkg, _) => pkg.create(packageName, shared = Some(true))
             }

             assetHelper.withCleaner(wsk.action, fullQualifiedName) {
                 val file = Some(TestUtils.getTestActionFilename("wc.js"))
                 (action, _) => action.create(fullQualifiedName, file)
             }

             assetHelper.withCleaner(wsk.action, name) {
                 (action, _) => action.create(name, Some(fullQualifiedName), Some("copy"))
             }

             val run = wsk.action.invoke(name, Map("payload" -> testString.toJson))
             withActivation(wsk.activation, run) {
                 activation =>
                     activation.response.status shouldBe "success"
                     activation.response.result shouldBe Some(testResult)
                     activation.logs.get.mkString(" ") should include(testString)
             }
     }

     it should "copy an action and ensure exec, parameters, and annotations copied" in withAssetCleaner(wskprops) {
         (wp, assetHelper) =>
             val origActionName = "orignAction"
             val copiedActionName = "copiedAction"
             val params = Map("a" -> "A".toJson)
             val annots = Map("b" -> "B".toJson)

             assetHelper.withCleaner(wsk.action, origActionName) {
                 val file = Some(TestUtils.getTestActionFilename("wc.js"))
                 (action, _) => action.create(origActionName, file, parameters = params, annotations = annots)
             }

             assetHelper.withCleaner(wsk.action, copiedActionName) {
                 (action, _) => action.create(copiedActionName, Some(origActionName), Some("copy"))
             }

             val copiedAction = getJSONFromCLIResponse(wsk.action.get(copiedActionName).stdout)
             val origAction = getJSONFromCLIResponse(wsk.action.get(copiedActionName).stdout)

             copiedAction.fields("annotations") shouldBe origAction.fields("annotations")
             copiedAction.fields("parameters") shouldBe origAction.fields("parameters")
             copiedAction.fields("exec") shouldBe origAction.fields("exec")
             copiedAction.fields("version") shouldBe JsString("0.0.1")
     }

     it should "recreate and invoke a new action with different code" in withAssetCleaner(wskprops) {
         (wp, assetHelper) =>
             val name = "recreatedAction"
             assetHelper.withCleaner(wsk.action, name, false) {
                 (action, _) => action.create(name, Some(TestUtils.getTestActionFilename("wc.js")))
             }

             val run1 = wsk.action.invoke(name, Map("payload" -> testString.toJson))
             withActivation(wsk.activation, run1) {
                 activation =>
                     activation.response.status shouldBe "success"
                     activation.logs.get.mkString(" ") should include(s"The message '$testString' has")
             }

             wsk.action.delete(name)
             assetHelper.withCleaner(wsk.action, name) {
                 (action, _) => action.create(name, Some(TestUtils.getTestActionFilename("hello.js")))
             }

             val run2 = wsk.action.invoke(name, Map("payload" -> testString.toJson))
             withActivation(wsk.activation, run2) {
                 activation =>
                     activation.response.status shouldBe "success"
                     activation.logs.get.mkString(" ") should include(s"hello $testString")
             }
     }

     it should "fail to invoke an action with an empty file" in withAssetCleaner(wskprops) {
         (wp, assetHelper) =>
             val name = "empty"
             assetHelper.withCleaner(wsk.action, name) {
                 (action, _) => action.create(name, Some(TestUtils.getTestActionFilename("empty.js")))
             }
             val run = wsk.action.invoke(name)
             withActivation(wsk.activation, run) {
                 activation =>
                     activation.response.status shouldBe "action developer error"
                     activation.response.result shouldBe Some(JsObject("error" -> "Missing main/no code to execute.".toJson))
             }
     }

     it should "create an action with an empty file" in withAssetCleaner(wskprops) {
         (wp, assetHelper) =>
             val name = "empty"
             assetHelper.withCleaner(wsk.action, name) {
                 (action, _) => action.create(name, Some(TestUtils.getTestActionFilename("empty.js")))
             }
             val rr = wsk.action.get(name)
             wsk.parseJsonString(rr.stdout).getFieldPath("exec", "code") shouldBe Some(JsString(""))
     }

     it should "blocking invoke of nested blocking actions" in withAssetCleaner(wskprops) {
         (wp, assetHelper) =>
             val name = "nestedBlockingAction"
             val child = "wc"

             assetHelper.withCleaner(wsk.action, name) {
                 (action, _) => action.create(name, Some(TestUtils.getTestActionFilename("wcbin.js")))
             }
             assetHelper.withCleaner(wsk.action, child) {
                 (action, _) => action.create(child, Some(TestUtils.getTestActionFilename("wc.js")))
             }

             val run = wsk.action.invoke(name, Map("payload" -> testString.toJson), blocking = true)
             val activation = wsk.parseJsonString(run.stdout).convertTo[CliActivation]

             withClue(s"check failed for activation: $activation") {
                 val wordCount = testString.split(" ").length
                 activation.response.result.get shouldBe JsObject("binaryCount" -> s"${wordCount.toBinaryString} (base 2)".toJson)
             }
     }

     it should "blocking invoke an asynchronous action" in withAssetCleaner(wskprops) {
         (wp, assetHelper) =>
             val name = "helloAsync"
             assetHelper.withCleaner(wsk.action, name) {
                 (action, _) => action.create(name, Some(TestUtils.getTestActionFilename("helloAsync.js")))
             }

             val run = wsk.action.invoke(name, Map("payload" -> testString.toJson), blocking = true)
             val activation = wsk.parseJsonString(run.stdout).convertTo[CliActivation]

             withClue(s"check failed for activation: $activation") {
                 activation.response.status shouldBe "success"
                 activation.response.result shouldBe Some(testResult)
                 activation.logs shouldBe Some(List())
             }
     }

     it should "return the value of the first synchronous whisk.done()" in withAssetCleaner(wskprops) {
         (wp, assetHelper) =>
             val name = "helloSyncDoneTwice"
             assetHelper.withCleaner(wsk.action, name) {
                 (action, _) => action.create(name, Some(TestUtils.getTestActionFilename("helloSyncDoneTwice.js")))
             }

             val run = wsk.action.invoke(name, Map("payload" -> testString.toJson))
             withActivation(wsk.activation, run) {
                 activation =>
                     activation.response.status shouldBe "success"
                     activation.response.result shouldBe Some(testResult)
                     activation.logs.get.mkString(" ") should include(testString)
             }
     }

     it should "return the value of the first asynchronous whisk.done()" in withAssetCleaner(wskprops) {
         (wp, assetHelper) =>
             val name = "helloSyncDoneTwice"
             assetHelper.withCleaner(wsk.action, name) {
                 (action, _) => action.create(name, Some(TestUtils.getTestActionFilename("helloAsyncDoneTwice.js")))
             }

             val run = wsk.action.invoke(name, Map("payload" -> testString.toJson))
             withActivation(wsk.activation, run) {
                 activation =>
                     activation.response.status shouldBe "success"
                     activation.response.result shouldBe Some(testResult)
                     activation.logs.get.mkString(" ") should include(testString)
             }
     }

     it should "reject an invoke with the wrong parameters set" in withAssetCleaner(wskprops) {
         (wp, assetHelper) =>
             val fullQualifiedName = s"/$guestNamespace/samples/helloWorld"
             val payload = "bob"
             val rr = wsk.cli(Seq("action", "invoke", fullQualifiedName, payload) ++ wskprops.overrides,
                 expectedExitCode = TestUtils.ERROR_EXIT)
             rr.stderr should include("Run 'wsk --help' for usage.")
             rr.stderr should include(s"error: Invalid argument(s): $payload")
     }

     it should "not be able to use 'ping' in an action" in withAssetCleaner(wskprops) {
         (wp, assetHelper) =>
             val name = "ping"
             assetHelper.withCleaner(wsk.action, name) {
                 (action, _) => action.create(name, Some(TestUtils.getTestActionFilename("ping.js")))
             }

             val run = wsk.action.invoke(name, Map("payload" -> "google.com".toJson))
             withActivation(wsk.activation, run) {
                 activation =>
                     activation.response.result shouldBe Some(JsObject(
                         "stderr" -> "ping: icmp open socket: Operation not permitted\n".toJson,
                         "stdout" -> "".toJson))
             }
     }

     ignore should "support UTF-8 as input and output format" in withAssetCleaner(wskprops) {
         (wp, assetHelper) =>
             val name = "utf8Test"
             assetHelper.withCleaner(wsk.action, name) {
                 (action, _) => action.create(name, Some(TestUtils.getTestActionFilename("hello.js")))
             }

             val utf8 = "«ταБЬℓσö»: 1<2 & 4+1>³, now 20%€§$ off!"
             val run = wsk.action.invoke(name, Map("payload" -> utf8.toJson))
             withActivation(wsk.activation, run) {
                 activation =>
                     activation.response.status shouldBe "success"
                     activation.logs.get.mkString(" ") should include(s"hello $utf8")
             }
     }

 }
	/*
	* Copyright 2015-2016 IBM Corporation
	*
	* Licensed 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 system.basic

	import org.junit.runner.RunWith
	import org.scalatest.junit.JUnitRunner

	import common.JsHelpers
	import common.TestHelpers
	import common.TestUtils
	import common.Wsk
	import common.WskProps
	import common.WskTestHelpers
	import spray.json._
	import spray.json.DefaultJsonProtocol._
	import spray.json.JsObject
	import spray.json.pimpAny

	@RunWith(classOf[JUnitRunner])
	class WskActionTests
	extends TestHelpers
	with WskTestHelpers
	with JsHelpers {

	implicit val wskprops = WskProps()
	val wsk = new Wsk

	val testString = "this is a test"
	val testResult = JsObject("count" -> testString.split(" ").length.toJson)
	val guestNamespace = wskprops.namespace

	behavior of "Whisk actions"

	it should "invoke an action returning a promise" in withAssetCleaner(wskprops) {
	(wp, assetHelper) =>
	val name = "hello promise"
	assetHelper.withCleaner(wsk.action, name) {
	(action, _) => action.create(name, Some(TestUtils.getTestActionFilename("helloPromise.js")))
	}

	val run = wsk.action.invoke(name)
	withActivation(wsk.activation, run) {
	activation =>
	activation.response.status shouldBe "success"
	activation.response.result shouldBe Some(JsObject("done" -> true.toJson))
	activation.logs.get.mkString(" ") shouldBe empty
	}
	}

	it should "invoke an action with a space in the name" in withAssetCleaner(wskprops) {
	(wp, assetHelper) =>
	val name = "hello Async"
	assetHelper.withCleaner(wsk.action, name) {
	(action, _) => action.create(name, Some(TestUtils.getTestActionFilename("helloAsync.js")))
	}

	val run = wsk.action.invoke(name, Map("payload" -> testString.toJson))
	withActivation(wsk.activation, run) {
	activation =>
	activation.response.status shouldBe "success"
	activation.response.result shouldBe Some(testResult)
	activation.logs.get.mkString(" ") should include(testString)
	}
	}

	it should "pass parameters bound on creation-time to the action" in withAssetCleaner(wskprops) {
	(wp, assetHelper) =>
	val name = "printParams"
	val params = Map(
	"param1" -> "test1",
	"param2" -> "test2")

	assetHelper.withCleaner(wsk.action, name) {
	(action, _) =>
	action.create(
	name,
	Some(TestUtils.getTestActionFilename("printParams.js")),
	parameters = params.mapValues(_.toJson))
	}

	val invokeParams = Map("payload" -> testString)
	val run = wsk.action.invoke(name, invokeParams.mapValues(_.toJson))
	withActivation(wsk.activation, run) {
	activation =>
	val logs = activation.logs.get.mkString(" ")

	(params ++ invokeParams).foreach {
	case (key, value) =>
	logs should include(s"params.$key: $value")
	}
	}
	}

	it should "copy an action and invoke it successfully" in withAssetCleaner(wskprops) {
	(wp, assetHelper) =>
	val name = "copied"
	val packageName = "samples"
	val actionName = "wordcount"
	val fullQualifiedName = s"/$guestNamespace/$packageName/$actionName"

	assetHelper.withCleaner(wsk.pkg, packageName) {
	(pkg, _) => pkg.create(packageName, shared = Some(true))
	}

	assetHelper.withCleaner(wsk.action, fullQualifiedName) {
	val file = Some(TestUtils.getTestActionFilename("wc.js"))
	(action, _) => action.create(fullQualifiedName, file)
	}

	assetHelper.withCleaner(wsk.action, name) {
	(action, _) => action.create(name, Some(fullQualifiedName), Some("copy"))
	}

	val run = wsk.action.invoke(name, Map("payload" -> testString.toJson))
	withActivation(wsk.activation, run) {
	activation =>
	activation.response.status shouldBe "success"
	activation.response.result shouldBe Some(testResult)
	activation.logs.get.mkString(" ") should include(testString)
	}
	}

	it should "copy an action and ensure exec, parameters, and annotations copied" in withAssetCleaner(wskprops) {
	(wp, assetHelper) =>
	val origActionName = "orignAction"
	val copiedActionName = "copiedAction"
	val params = Map("a" -> "A".toJson)
	val annots = Map("b" -> "B".toJson)

	assetHelper.withCleaner(wsk.action, origActionName) {
	val file = Some(TestUtils.getTestActionFilename("wc.js"))
	(action, _) => action.create(origActionName, file, parameters = params, annotations = annots)
	}

	assetHelper.withCleaner(wsk.action, copiedActionName) {
	(action, _) => action.create(copiedActionName, Some(origActionName), Some("copy"))
	}

	val copiedAction = getJSONFromCLIResponse(wsk.action.get(copiedActionName).stdout)
	val origAction = getJSONFromCLIResponse(wsk.action.get(copiedActionName).stdout)

	copiedAction.fields("annotations") shouldBe origAction.fields("annotations")
	copiedAction.fields("parameters") shouldBe origAction.fields("parameters")
	copiedAction.fields("exec") shouldBe origAction.fields("exec")
	copiedAction.fields("version") shouldBe JsString("0.0.1")
	}

	it should "recreate and invoke a new action with different code" in withAssetCleaner(wskprops) {
	(wp, assetHelper) =>
	val name = "recreatedAction"
	assetHelper.withCleaner(wsk.action, name, false) {
	(action, _) => action.create(name, Some(TestUtils.getTestActionFilename("wc.js")))
	}

	val run1 = wsk.action.invoke(name, Map("payload" -> testString.toJson))
	withActivation(wsk.activation, run1) {
	activation =>
	activation.response.status shouldBe "success"
	activation.logs.get.mkString(" ") should include(s"The message '$testString' has")
	}

	wsk.action.delete(name)
	assetHelper.withCleaner(wsk.action, name) {
	(action, _) => action.create(name, Some(TestUtils.getTestActionFilename("hello.js")))
	}

	val run2 = wsk.action.invoke(name, Map("payload" -> testString.toJson))
	withActivation(wsk.activation, run2) {
	activation =>
	activation.response.status shouldBe "success"
	activation.logs.get.mkString(" ") should include(s"hello $testString")
	}
	}

	it should "fail to invoke an action with an empty file" in withAssetCleaner(wskprops) {
	(wp, assetHelper) =>
	val name = "empty"
	assetHelper.withCleaner(wsk.action, name) {
	(action, _) => action.create(name, Some(TestUtils.getTestActionFilename("empty.js")))
	}
	val run = wsk.action.invoke(name)
	withActivation(wsk.activation, run) {
	activation =>
	activation.response.status shouldBe "action developer error"
	activation.response.result shouldBe Some(JsObject("error" -> "Missing main/no code to execute.".toJson))
	}
	}

	it should "create an action with an empty file" in withAssetCleaner(wskprops) {
	(wp, assetHelper) =>
	val name = "empty"
	assetHelper.withCleaner(wsk.action, name) {
	(action, _) => action.create(name, Some(TestUtils.getTestActionFilename("empty.js")))
	}
	val rr = wsk.action.get(name)
	wsk.parseJsonString(rr.stdout).getFieldPath("exec", "code") shouldBe Some(JsString(""))
	}

	it should "blocking invoke of nested blocking actions" in withAssetCleaner(wskprops) {
	(wp, assetHelper) =>
	val name = "nestedBlockingAction"
	val child = "wc"

	assetHelper.withCleaner(wsk.action, name) {
	(action, _) => action.create(name, Some(TestUtils.getTestActionFilename("wcbin.js")))
	}
	assetHelper.withCleaner(wsk.action, child) {
	(action, _) => action.create(child, Some(TestUtils.getTestActionFilename("wc.js")))
	}

	val run = wsk.action.invoke(name, Map("payload" -> testString.toJson), blocking = true)
	val activation = wsk.parseJsonString(run.stdout).convertTo[CliActivation]

	withClue(s"check failed for activation: $activation") {
	val wordCount = testString.split(" ").length
	activation.response.result.get shouldBe JsObject("binaryCount" -> s"${wordCount.toBinaryString} (base 2)".toJson)
	}
	}

	it should "blocking invoke an asynchronous action" in withAssetCleaner(wskprops) {
	(wp, assetHelper) =>
	val name = "helloAsync"
	assetHelper.withCleaner(wsk.action, name) {
	(action, _) => action.create(name, Some(TestUtils.getTestActionFilename("helloAsync.js")))
	}

	val run = wsk.action.invoke(name, Map("payload" -> testString.toJson), blocking = true)
	val activation = wsk.parseJsonString(run.stdout).convertTo[CliActivation]

	withClue(s"check failed for activation: $activation") {
	activation.response.status shouldBe "success"
	activation.response.result shouldBe Some(testResult)
	activation.logs shouldBe Some(List())
	}
	}

	it should "return the value of the first synchronous whisk.done()" in withAssetCleaner(wskprops) {
	(wp, assetHelper) =>
	val name = "helloSyncDoneTwice"
	assetHelper.withCleaner(wsk.action, name) {
	(action, _) => action.create(name, Some(TestUtils.getTestActionFilename("helloSyncDoneTwice.js")))
	}

	val run = wsk.action.invoke(name, Map("payload" -> testString.toJson))
	withActivation(wsk.activation, run) {
	activation =>
	activation.response.status shouldBe "success"
	activation.response.result shouldBe Some(testResult)
	activation.logs.get.mkString(" ") should include(testString)
	}
	}

	it should "return the value of the first asynchronous whisk.done()" in withAssetCleaner(wskprops) {
	(wp, assetHelper) =>
	val name = "helloSyncDoneTwice"
	assetHelper.withCleaner(wsk.action, name) {
	(action, _) => action.create(name, Some(TestUtils.getTestActionFilename("helloAsyncDoneTwice.js")))
	}

	val run = wsk.action.invoke(name, Map("payload" -> testString.toJson))
	withActivation(wsk.activation, run) {
	activation =>
	activation.response.status shouldBe "success"
	activation.response.result shouldBe Some(testResult)
	activation.logs.get.mkString(" ") should include(testString)
	}
	}

	it should "reject an invoke with the wrong parameters set" in withAssetCleaner(wskprops) {
	(wp, assetHelper) =>
	val fullQualifiedName = s"/$guestNamespace/samples/helloWorld"
	val payload = "bob"
	val rr = wsk.cli(Seq("action", "invoke", fullQualifiedName, payload) ++ wskprops.overrides,
	expectedExitCode = TestUtils.ERROR_EXIT)
	rr.stderr should include("Run 'wsk --help' for usage.")
	rr.stderr should include(s"error: Invalid argument(s): $payload")
	}

	it should "not be able to use 'ping' in an action" in withAssetCleaner(wskprops) {
	(wp, assetHelper) =>
	val name = "ping"
	assetHelper.withCleaner(wsk.action, name) {
	(action, _) => action.create(name, Some(TestUtils.getTestActionFilename("ping.js")))
	}

	val run = wsk.action.invoke(name, Map("payload" -> "google.com".toJson))
	withActivation(wsk.activation, run) {
	activation =>
	activation.response.result shouldBe Some(JsObject(
	"stderr" -> "ping: icmp open socket: Operation not permitted\n".toJson,
	"stdout" -> "".toJson))
	}
	}

	ignore should "support UTF-8 as input and output format" in withAssetCleaner(wskprops) {
	(wp, assetHelper) =>
	val name = "utf8Test"
	assetHelper.withCleaner(wsk.action, name) {
	(action, _) => action.create(name, Some(TestUtils.getTestActionFilename("hello.js")))
	}

	val utf8 = "«ταБЬℓσö»: 1<2 & 4+1>³, now 20%€§$ off!"
	val run = wsk.action.invoke(name, Map("payload" -> utf8.toJson))
	withActivation(wsk.activation, run) {
	activation =>
	activation.response.status shouldBe "success"
	activation.logs.get.mkString(" ") should include(s"hello $utf8")
	}
	}

	}