public void Features_IsEnabled_ReturnsTrue_WhenPathIsMoreComplexThanFeatureInRegistry()
 {
     // test feature a/b/c where value in registry is just a (signifying all features registered)
     var feature = new Feature("a");
     var attribute = new FeatureAttribute("a", "b", "c");
     Assert.True(Features.IsEnabled(SetupRegistry(feature), new[] { "a", "b", "c" }));
 }

 public Scenario(Feature feature)
 {
     Steps = new List<Step>();
     Components = new List<Component>();
     Container = feature.Container.Scope();
     Props = new Dictionary<string, object>();
 }

 public GenericHandler(string contentType, EndpointAttributes handlerAttributes, Feature usesFeature)
 {
     this.HandlerContentType = contentType;
     this.ContentTypeAttribute = ContentType.GetEndpointAttributes(contentType);
     this.HandlerAttributes = handlerAttributes;
     this.usesFeature = usesFeature;
 }

        public void SetPropertyValue()
        {
            var ft = new Feature(Exp.SomeFeature);
            ft = ft.Set(Exp.SomeProperty, 10);

            Assert.Equal(10, ft.Get(Exp.SomeProperty));
        }

        private void ExceptionsScreen_OnLoaded(object sender, RoutedEventArgs e)
        {
            var core = AppContextObsolete.AppContext;
            var feature = new Feature(@"Exceptions", @"Load");
            try
            {
                var s = Stopwatch.StartNew();

                try
                {
                    FeatureManager.CreateSchema(core.DbContextCreator);
                }
                catch { }

                core.FeatureManager.Load(core.DbContextCreator);

                core.FeatureManager.Write(feature, string.Empty);
                this.ViewModel.Load(
                    ExceptionsDataProvider.GetTimePeriods,
                    ExceptionsDataProvider.GetVersions,
                    ExceptionsDataProvider.GetExceptions,
                    ExceptionsDataProvider.GetExceptionsCounts);
                s.Stop();
                Debug.WriteLine(s.ElapsedMilliseconds);
            }
            catch (Exception ex)
            {
                core.Log(ex.ToString(), LogLevel.Error);
                core.FeatureManager.Write(feature, ex);
            }
        }

        public void ShouldRecordInstrumentationForIsEnabled([Values(true,false)] Boolean enabled)
        {
            var instrumenter = new MockInstrumenter();
            var feature = new Feature("Name", new MemoryAdapter(), instrumenter);

            if (enabled)
            {
                feature.Enable();
            } else
            {
                feature.Disable();
            }
            instrumenter.Events.Clear();

            feature.IsEnabled();

            var expectedPayload = new InstrumentationPayload {
                FeatureName = "Name",
                Operation = "enabled?",
                Thing = null,
                Result = enabled
            };
            var expectedEvent = new MockInstrumenter.Event {
                Type = InstrumentationType.FeatureOperation,
                Payload = expectedPayload,
            };

            Assert.That(instrumenter.Events, Has.Member(expectedEvent));
        }

        /// <summary>
        /// Check if this device is supporting a feature.
        /// </summary>
        /// <param name="feature">The feature to check.</param>
        /// <returns>
        /// Returns true if this device supports this feature, otherwise false.
        /// </returns>
        public bool CheckFeatureSupport(Feature feature)
        {
            unsafe
            {
                switch (feature)
                {
                    case Feature.Doubles:
                        {
                            FeatureDataDoubles support;

                            if (CheckFeatureSupport(Feature.Doubles, new IntPtr(&support), Utilities.SizeOf<FeatureDataDoubles>()).Failure)
                                return false;
                            return support.DoublePrecisionFloatShaderOps;
                        }
                    case Feature.D3D10XHardwareOptions:
                        {
                            FeatureDataD3D10XHardwareOptions support;
                            if (CheckFeatureSupport(Feature.D3D10XHardwareOptions, new IntPtr(&support), Utilities.SizeOf<FeatureDataD3D10XHardwareOptions>()).Failure)
                                return false;
                            return support.ComputeShadersPlusRawAndStructuredBuffersViaShader4X;
                        }
                    default:
                        throw new SharpDXException("Unsupported Feature. Use specialized CheckXXX methods");
                }
            }
        }

        public PopupUserControl(Feature feature)
        {
            InitializeComponent();

            string speed = feature.ColumnValues["Speed"];
            string name = feature.ColumnValues["VehicleName"];
            string latitude = feature.ColumnValues["Latitude"];
            string dateTime = feature.ColumnValues["DateTime"];
            string longitude = feature.ColumnValues["Longitude"];

            txtName.Text = name;
            double x, y;
            if (double.TryParse(longitude, out x) && double.TryParse(latitude, out y))
            {
                ManagedProj4Projection proj4 = new ManagedProj4Projection();
                proj4.InternalProjectionParametersString = Proj4Projection.GetDecimalDegreesParametersString();
                proj4.ExternalProjectionParametersString = Proj4Projection.GetGoogleMapParametersString();
                proj4.Open();

                Vertex vertex = proj4.ConvertToInternalProjection(x, y);
                txtLongitude.Text = vertex.X.ToString("N6", CultureInfo.InvariantCulture);
                txtLatitude.Text = vertex.Y.ToString("N6", CultureInfo.InvariantCulture);

                proj4.Close();
            }
            else
            {
                txtLongitude.Text = longitude;
                txtLatitude.Text = latitude;
            }

            txtSpeed.Text = speed + " mph";
            txtTime.Text = dateTime;
        }

 public void Should_set_tags_for_feature_event()
 {
     var feature = new Feature("featureTitle");
     feature.AddTags(new[] { "tag1", "tag2" });
     sut.OnFeatureStartedEvent(feature);
     CollectionAssert.AreEqual(new[] { "tag1", "tag2" }, featureContext.Tags);
 }

        private void convertFeatureToWkb_Click(object sender, RoutedEventArgs e)
        {
            Feature feature = new Feature(wktTextBox.Text);
            byte[] wellKnownBinary = feature.GetWellKnownBinary();

            wkbResultTextBox.Text = Convert.ToBase64String(wellKnownBinary);
        }

        private void convertWkbToFeature_Click(object sender, RoutedEventArgs e)
        {
            byte[] wellKnownBinary = Convert.FromBase64String(wkbTextBox.Text);
            Feature feature = new Feature(wellKnownBinary);

            wktResultTextBox.Text = feature.GetWellKnownText();
        }

        public void Should_add_table_steps_to_scenario()
        {
            var gherkinEvents = MockRepository.GenerateStub<IGherkinParserEvents>();
            var stepBuilder = new StepBuilder(gherkinEvents);
            var feature = new Feature("title");
            var scenario = new Scenario("title", "source", feature);
            gherkinEvents.Raise(_ => _.FeatureEvent += null, this, new EventArgs<Feature>(feature));
            gherkinEvents.Raise(_ => _.ScenarioEvent += null, this, new EventArgs<Scenario>(scenario));
            gherkinEvents.Raise(_ => _.StepEvent += null, this, new EventArgs<StringStep>(new StringStep("step 1", "source")));
            gherkinEvents.Raise(_ => _.StepEvent += null, this, new EventArgs<StringStep>(new StringStep("step 2", "source")));
            gherkinEvents.Raise(_ => _.TableEvent += null, this,
                                new EventArgs<IList<IList<Token>>>(new List<IList<Token>>
                                                                       {
                                                                           new List<Token>
                                                                               {
                                                                                   new Token("A", new LineInFile(1)),
                                                                                   new Token("B", new LineInFile(1))
                                                                               },
                                                                           new List<Token>
                                                                               {
                                                                                   new Token("1", new LineInFile(2)),
                                                                                   new Token("2", new LineInFile(2))
                                                                               },

                                                                       }));
            gherkinEvents.Raise(_ => _.EofEvent += null, this, new EventArgs());

            Assert.That(scenario.Steps.Count(), Is.EqualTo(2));
            Assert.That(scenario.Steps.ToList()[0], Is.TypeOf<StringStep>());
            Assert.That(scenario.Steps.ToList()[1], Is.TypeOf<StringTableStep>());
        }

        public void FeaturesAreNotSame()
        {
            var feature1 = new Feature<Point>
            {
                Geometry = new Point { X = 50.342, Y = -2, SpatialReference = SpatialReference.WGS84 }
            };

            var feature2 = new Feature<Point>
            {
                Geometry = new Point { X = 50.342, Y = -30.331, SpatialReference = SpatialReference.WGS84 }
            };

            var feature3 = new Feature<Point>
            {
                Geometry = new Point { X = 50.342, Y = -30.331, SpatialReference = SpatialReference.WGS84 }
            };
            feature3.Attributes.Add("random", "rtcxbvbx");
            feature3.Attributes.Add("something", 45445);

            var feature4 = new Feature<Point>
            {
                Geometry = new Point { X = 50.342, Y = -30.331, SpatialReference = SpatialReference.WGS84 }
            };
            feature4.Attributes.Add("random", "rtcxbvbx");
            feature4.Attributes.Add("something", 4);

            Assert.NotEqual(feature1, feature2);
            Assert.NotEqual(feature3, feature4);
            Assert.NotEqual(feature1, feature3);
            Assert.NotEqual(feature1, feature4);
            Assert.NotEqual(feature2, feature3);
            Assert.NotEqual(feature2, feature4);
        }

    public static void Main(string[] args)
    {
        var binaries = new Feature("MyApp Binaries", "Application binaries");
        var docs = new Feature("MyApp Documentation");
        var tuts = new Feature("MyApp Tutorial");

        docs.Add(tuts);
        binaries.Add(docs);

        var project =
            new Project("MyProduct",
                new Dir(@"%ProgramFiles%\My Company\My Product",
                    new File(binaries, @"Files\Bin\MyApp.exe"),
                    new Dir(@"Docs\Manual",
                        new File(docs, @"Files\Docs\Manual.txt"),
                        new File(tuts, @"Files\Docs\Tutorial.txt"))));

        project.GUID = new Guid("6f330b47-2577-43ad-9095-1861ba25889b");
        project.UI = WUI.WixUI_FeatureTree;

        project.DefaultFeature = binaries; //this line is optional

        project.PreserveTempFiles = true;

        project.BuildMsi();
    }

 public void SetUp()
 {
     FlipperActor = MockActor("User:5");
     StatsdClient = MockRepository.GenerateStub<IStatsd>();
     Instrumenter = new StatsdInstrumenter(StatsdClient);
     Feature = new Feature("Name", new MemoryAdapter(), Instrumenter);
 }

 public void Should_update_featureContext_with_feature_title()
 {
     const string featureTitle = "feature title";
     var f = new Feature(featureTitle);
     sut.OnFeatureStartedEvent(f);
     Assert.That(featureContext.FeatureTitle, Is.EqualTo(featureTitle));
 }

 public FeatureNode(FileSystemInfoBase location, string relativePathFromRoot, Feature feature)
 {
     this.OriginalLocation = location;
     this.OriginalLocationUrl = location.ToUri();
     this.RelativePathFromRoot = relativePathFromRoot;
     this.Feature = feature;
 }

        private void btnBegin_Click(object sender, RoutedEventArgs e)
        {
            int pointsCount = Convert.ToInt32(((ComboBoxItem)cbxPointCount.SelectedItem).Content);
            LayerOverlay pointsOverlay = (LayerOverlay)wpfMap1.Overlays["PointsOverlay"];
            InMemoryFeatureLayer pointsLayer = (InMemoryFeatureLayer)pointsOverlay.Layers["PointsLayer"];

            pointsLayer.InternalFeatures.Clear();
            for (int i = 0; i < pointsCount; i++)
            {
                PointShape pointShape = GetRandomPoint(pointsBoundary);
                string id = GetRandomDirection().ToString();
                Feature feature = new Feature(pointShape.X, pointShape.Y, id);
                pointsLayer.InternalFeatures.Add(feature);
            }

            pointsOverlay.Refresh();

            // Starts the move points timer
            movePointsTimer.Change(0, Convert.ToInt32(((ComboBoxItem)cbxRedrawInterval.SelectedItem).Content));

            // Starts the color changing timer
            changeColorTimer.Change(0, Convert.ToInt32(((ComboBoxItem)cbxChangeColorInterval.SelectedItem).Content));

            btnBegin.IsEnabled = false;
            btnStop.IsEnabled = true;
        }

 public void DynamicEnabledFeatureIsEnabled()
 {
     var method = typeof(FeatureFacts)
         .GetMethod("Enabled");
     var feature = new Feature("DynamicDisabled", method);
     Assert.True(feature.IsEnabled);
 }

    public static void LogFeature(Feature feature)
    {
        System.Console.WriteLine("-----------------");
        System.Console.WriteLine("Feature : "+feature.Reference);
        System.Console.WriteLine("Feature is lifetime : "+feature.IsLifetime());

        if( !feature.IsLifetime() )
        {
            System.Console.WriteLine("Feature TTL : "+feature.Ttl);
        }

        System.Console.WriteLine("Feature has value : "+feature.HasValue());

        if( feature.HasValue() )
        {
            System.Console.WriteLine("Feature value : "+feature.Value);
        }

        System.Console.WriteLine("Feature is in bundle : "+feature.IsInBundle());

        if( feature.IsInBundle() )
        {
            System.Console.WriteLine("Feature bundle : "+feature.BundleReference);
        }

        System.Console.WriteLine("-----------------");
    }