internal static MagickGeometry Create(Wrapper.MagickGeometry value)
    {
      if (value == null)
        return null;

      return new MagickGeometry(value);
    }

    public static Wrapper Create(object value)
    {
        Wrapper result = new Wrapper(value);
        result.autorelease();

        return result;
    }

		public CodeExpression GenerateNewInstanceCode (Wrapper.Widget widget)
		{
			CodeExpression exp = widget.GenerateObjectCreation (this);
			CodeExpression var = GenerateInstanceExpression (widget, exp);
			GenerateBuildCode (widget, var);
			return var;
		}

 public Gradient3ColorsViewModel()
 {
     Func<object, Tuple<bool, double>> converter = (o) => Tuple.Create(o.IsDouble(), o.ToDouble());
     LowValue = new Wrapper<double>(converter);
     MidValue = new Wrapper<double>(converter);
     HighValue = new Wrapper<double>(converter);
 }

 //Dictionary<string, string> p = new Dictionary<string, string>{ {"name" , "gan3ma2"} , {"room_no" , "252"} };
 //Dictionary<string, string> t = new Dictionary<string, string>{ {"play_id" , "7"} , {"user_id" , "38"}};
 // Use this for initialization
 void Start()
 {
     W = GameObject.Find ("Wrapper").GetComponent<Wrapper> ();
     //p ["name"] = "gan3ma";
     url = "http://192.168.3.83:3000/plays/7/pieces";
     W.GET (url);
 }

 public void SerializeWrappedDeepList()
 {
     Program.ExpectFailure<NotSupportedException>(() =>
     {
         var wrapped = new Wrapper();
         var clone = Serializer.DeepClone(wrapped);
     }, "Nested or jagged lists and arrays are not supported");
 }

 public void SetUp()
 {
     node1 = new Wrapper(typeof(FakeJsonBehavior));
     node2 = new Wrapper(typeof(FakeJsonBehavior));
     node3 = new Wrapper(typeof(FakeJsonBehavior));
     node1.AddToEnd(node2);
     node1.AddToEnd(node3);
 }

 public JTreeStringTemplateModel(StringTemplate st)
 {
     if (st == null)
     {
         throw new System.ArgumentException("root is null");
     }
     root = new StringTemplateWrapper(st);
 }

        public void creating_an_object_def_for_full_tracing_should_wrap_with_a_behavior_tracer()
        {
            var node = new Wrapper(typeof (SimpleBehavior));
            var instance = new BehaviorTracerNode(node).As<IContainerModel>().ToInstance().As<IConfiguredInstance>();

            instance.PluggedType.ShouldBe(typeof (BehaviorTracer));
            instance.FindDependencyDefinitionFor<IActionBehavior>()
                .ReturnedType.ShouldBe(typeof (SimpleBehavior));
        }

        public void Simple(IObjectMapperAdapter mapper)
        {
            mapper.CreateMap<Wrapper<string>, ImmutableWrapper<string>>();

            var source = new Wrapper<string> { Value = "X" };
            var result = mapper.Map<ImmutableWrapper<string>>(source);

            Assert.Equal("X", result.Value);
        }

 public static WidgetMap GenerateCreationCode(CodeNamespace cns, CodeTypeDeclaration type, Wrapper.ActionGroup grp, CodeExpression groupVarExp, CodeStatementCollection statements, GenerationOptions options, ArrayList warnings)
 {
     statements.Add (new CodeCommentStatement ("Action group " + grp.Name));
     GeneratorContext ctx = new ProjectGeneratorContext (cns, type, statements, options);
     ctx.GenerateCreationCode (grp, groupVarExp);
     ctx.EndGeneration ();
     warnings.AddRange (ctx.Warnings);
     return ctx.WidgetMap;
 }

 static bool IsRemoved(Wrapper wrapper)
 {
     if (!wrapper.body.IsAdded)
     {
         wrapper.Dispose();
         return true;
     }
     return false;
 }

        public void SetUp()
        {
            inner = Wrapper.For<SimpleBehavior>();
            chain = new BehaviorChain();

            chain.AddToEnd(inner);

            theNode = new BehaviorTracerNode(inner);
        }

        public void append_with_no_behaviors()
        {
            var chain = new BehaviorChain();
            var wrapper = new Wrapper(typeof (ObjectDefInstanceTester.FakeJsonBehavior));

            chain.Append(wrapper);

            chain.Top.ShouldBeTheSameAs(wrapper);
        }

        public void adding_a_node_to_the_end_sets_the_chain_on_the_node()
        {
            var chain = new BehaviorChain();
            var wrapper = new Wrapper(typeof(ObjectDefInstanceTester.FakeJsonBehavior));

            chain.AddToEnd(wrapper);

            wrapper.ParentChain().ShouldBeTheSameAs(chain);
        }

        public void SetUp()
        {
            inner = Wrapper.For<SimpleBehavior>();
            chain = new BehaviorChain();

            chain.AddToEnd(inner);

            theNode = new DiagnosticNode(chain);
        }

        public void creating_an_object_def_for_full_tracing_should_wrap_with_a_behavior_tracer()
        {
            var node = new Wrapper(typeof(SimpleBehavior));
            var objectDef = new BehaviorTracerNode(node).As<IContainerModel>().ToObjectDef();

            objectDef.Type.ShouldEqual(typeof(BehaviorTracer));
            objectDef.DependencyFor<IActionBehavior>().As<ConfiguredDependency>()
                .Definition.Type.ShouldEqual(typeof(SimpleBehavior));
        }

        public IAsyncResult Enqueue(object request, AsyncCallback callback, object state)
        {
            var wrapper = new Wrapper(callback, state);
            lock (_items)
            {
                _items.Add(request, wrapper);
            }

            return wrapper;
        }

            public static BaseEvent CreateWrapper(BaseEvent original, Action<BaseEvent, bool> passthrough, bool ignore_delay)
            {
                ConfigNode cn = new ConfigNode();
                original.OnSave(cn);
                Wrapper wrapper = new Wrapper(original, passthrough, ignore_delay);
                BaseEvent new_event = new BaseEvent(original.listParent, original.name, wrapper.Invoke);
                new_event.OnLoad(cn);

                return new_event;
            }

        public void PropertyToDictionaryEntry(IObjectMapperAdapter mapper)
        {
            mapper.CreateMap<Wrapper<string>, Dictionary<string, object>>();

            var source = new Wrapper<string> { Value = "ABC" };
            var result = mapper.Map<Dictionary<string, object>>(source);

            Assert.NotNull(result);
            Assert.Contains(new KeyValuePair<string, object>("Value", "ABC"), result);
        }