private IEnumerator Examples()
    {
        //  Get Author URL POST
        if (!_alchemyAPI.GetAuthors(OnGetAuthorsUrl, OnFail, _exampleURL_watsonJeopardy))
        {
            Log.Debug("ExampleAlchemyLanguage.GetAuthors()", "Failed to get authors URL POST!");
        }
        while (!_getAuthorsURLTested)
        {
            yield return(null);
        }

        //Get Author HTML POST
        if (!_alchemyAPI.GetAuthors(OnGetAuthorsHtml, OnFail, _watson_beats_jeopardy_html))
        {
            Log.Debug("ExampleAlchemyLanguage.GetAuthors()", "Failed to get authors HTML POST!");
        }
        while (!_getAuthorsHTMLTested)
        {
            yield return(null);
        }

        ////Get Concepts Text POST
        if (!_alchemyAPI.GetRankedConcepts(OnGetConceptsText, OnFail, _exampleText_watsonJeopardy))
        {
            Log.Debug("ExampleAlchemyLanguage.GetRankedConcepts()", "Failed to get concepts Text POST!");
        }
        while (!_getRankedConceptsTextTested)
        {
            yield return(null);
        }

        //Get Concepts HTML POST
        if (!_alchemyAPI.GetRankedConcepts(OnGetConceptsHtml, OnFail, _watson_beats_jeopardy_html))
        {
            Log.Debug("ExampleAlchemyLanguage.GetRankedConcepts()", "Failed to get concepts HTML POST!");
        }
        while (!_getRankedConceptsHTMLTested)
        {
            yield return(null);
        }

        //Get Concepts URL POST
        if (!_alchemyAPI.GetRankedConcepts(OnGetConceptsUrl, OnFail, _exampleURL_watsonJeopardy))
        {
            Log.Debug("ExampleAlchemyLanguage.GetRankedConcepts()", "Failed to get concepts url POST!");
        }
        while (!_getRankedConceptsURLTested)
        {
            yield return(null);
        }

        //Get Date URL POST
        if (!_alchemyAPI.GetDates(OnGetDatesUrl, OnFail, _exampleURL_watsonJeopardy))
        {
            Log.Debug("ExampleAlchemyLanguage.GetDates()", "Failed to get dates by URL POST");
        }
        while (!_getDatesURLTested)
        {
            yield return(null);
        }

        //Get Date Text POST
        if (!_alchemyAPI.GetDates(OnGetDatesText, OnFail, _exampleText_watsonJeopardy))
        {
            Log.Debug("ExampleAlchemyLanguage.GetDates()", "Failed to get dates by text POST");
        }
        while (!_getDatesTextTested)
        {
            yield return(null);
        }

        //Get Date HTML POST
        if (!_alchemyAPI.GetDates(OnGetDatesHtml, OnFail, _watson_beats_jeopardy_html))
        {
            Log.Debug("ExampleAlchemyLanguage.GetDates()", "Failed to get dates by HTML POST");
        }
        while (!_getDatesHTMLTested)
        {
            yield return(null);
        }

        //Get Emotions URL POST
        if (!_alchemyAPI.GetEmotions(OnGetEmotionsUrl, OnFail, _exampleURL_watsonJeopardy, true))
        {
            Log.Debug("ExampleAlchemyLanguage.GetEmotions()", "Failed to get emotions by URL POST");
        }
        while (!_getEmotionURLTested)
        {
            yield return(null);
        }

        //Get Emotions Text POST
        if (!_alchemyAPI.GetEmotions(OnGetEmotionsText, OnFail, _exampleText_watsonJeopardy, true))
        {
            Log.Debug("ExampleAlchemyLanguage.GetEmotions()", "Failed to get emotions by text POST");
        }
        while (!_getEmotionTextTested)
        {
            yield return(null);
        }

        //Get Emotions HTML POST
        if (!_alchemyAPI.GetEmotions(OnGetEmotionsHtml, OnFail, _watson_beats_jeopardy_html, true))
        {
            Log.Debug("ExampleAlchemyLanguage.GetEmotions()", "Failed to get emotions by HTML POST");
        }
        while (!_getEmotionHTMLTested)
        {
            yield return(null);
        }

        //Extract Entities URL POST
        if (!_alchemyAPI.ExtractEntities(OnExtractEntitiesUrl, OnFail, _exampleURL_watsonJeopardy))
        {
            Log.Debug("ExampleAlchemyLanguage.ExtractEntities()", "Failed to get entities by URL POST");
        }
        while (!_getEntityExtractionURLTested)
        {
            yield return(null);
        }

        //Extract Entities Text POST
        if (!_alchemyAPI.ExtractEntities(OnExtractEntitiesText, OnFail, _exampleText_watsonJeopardy))
        {
            Log.Debug("ExampleAlchemyLanguage.ExtractEntities()", "Failed to get entities by text POST");
        }
        while (!_getEntityExtractionTextTested)
        {
            yield return(null);
        }

        //Extract Entities HTML POST
        if (!_alchemyAPI.ExtractEntities(OnExtractEntitiesHtml, OnFail, _watson_beats_jeopardy_html))
        {
            Log.Debug("ExampleAlchemyLanguage.ExtractEntities()", "Failed to get entities by HTML POST");
        }
        while (!_getEntityExtractionHTMLTested)
        {
            yield return(null);
        }

        //Detect Feeds URL POST
        if (!_alchemyAPI.DetectFeeds(OnDetectFeedsUrl, OnFail, "http://time.com/newsfeed/"))
        {
            Log.Debug("ExampleAlchemyLanguage.DetectFeeds()", "Failed to get feeds by URL POST");
        }
        while (!_detectFeedsURLTested)
        {
            yield return(null);
        }

        ////Detect Feeds HTML POST
        //if (!_alchemyAPI.DetectFeeds(OnDetectFeedsHtml, OnFail, ycombinator_html))
        //    Log.Debug("ExampleAlchemyLanguage.DetectFeeds()", "Failed to get feeds by HTML POST");
        //while (!_detectFeedsHTMLTested)
        //    yield return null;

        //Extract Keywords URL POST
        if (!_alchemyAPI.ExtractKeywords(OnExtractKeywordsUrl, OnFail, _exampleURL_watsonJeopardy))
        {
            Log.Debug("ExampleAlchemyLanguage.ExtractKeywords()", "Failed to get keywords by URL POST");
        }
        while (!_getKeywordExtractionURLTested)
        {
            yield return(null);
        }

        //Extract Keywords Text POST
        if (!_alchemyAPI.ExtractKeywords(OnExtractKeywordsText, OnFail, _exampleText_watsonJeopardy))
        {
            Log.Debug("ExampleAlchemyLanguage.ExtractKeywords()", "Failed to get keywords by text POST");
        }
        while (!_getKeywordExtractionTextTested)
        {
            yield return(null);
        }

        //Extract Keywords HTML POST
        if (!_alchemyAPI.ExtractKeywords(OnExtractKeywordsHtml, OnFail, _watson_beats_jeopardy_html))
        {
            Log.Debug("ExampleAlchemyLanguage.ExtractKeywords()", "Failed to get keywords by HTML POST");
        }
        while (!_getKeywordExtractionHTMLTested)
        {
            yield return(null);
        }

        //Extract Languages URL POST
        if (!_alchemyAPI.GetLanguages(OnGetLanguagesUrl, OnFail, _exampleURL_watsonJeopardy))
        {
            Log.Debug("ExampleAlchemyLanguage.GetLanguages()", "Failed to get languages by text POST");
        }
        while (!_getLanguageURLTested)
        {
            yield return(null);
        }

        //Extract Languages Text POST
        if (!_alchemyAPI.GetLanguages(OnGetLanguagesText, OnFail, _exampleText_watsonJeopardy))
        {
            Log.Debug("ExampleAlchemyLanguage.GetLanguages()", "Failed to get languages by text POST");
        }
        while (!_getLanguageTextTested)
        {
            yield return(null);
        }

        //Extract Languages HTML POST
        if (!_alchemyAPI.GetLanguages(OnGetLanguagesHtml, OnFail, _watson_beats_jeopardy_html))
        {
            Log.Debug("ExampleAlchemyLanguage.GetLanguages()", "Failed to get languages by HTML POST");
        }
        while (!_getLanguageHTMLTested)
        {
            yield return(null);
        }

        //Get Microformats URL POST
        if (!_alchemyAPI.GetMicroformats(OnGetMicroformatsUrl, OnFail, _exampleURL_microformats))
        {
            Log.Debug("ExampleAlchemyLanguage.GetMicroformats()", "Failed to get microformats by text POST");
        }
        while (!_getMicroformatURLTested)
        {
            yield return(null);
        }

        //Get Microformats HTML POST
        //if (!_alchemyAPI.GetMicroformats(OnGetMicroformatsHtml, OnFail, microformats_html))
        //    Log.Debug("ExampleAlchemyLanguage.GetMicroformats()", "Failed to get microformats by text POST");
        //while (!_getMicroformatHTMLTested)
        //    yield return null;

        //Get PublicationDate URL POST
        if (!_alchemyAPI.GetPublicationDate(OnGetPublicationDateUrl, OnFail, _exampleURL_watsonJeopardy))
        {
            Log.Debug("ExampleAlchemyLanguage.GetPublicationDate()", "Failed to get publication dates by url POST");
        }
        while (!_getPubDateURLTested)
        {
            yield return(null);
        }

        //Get PublicationDate HTML POST
        if (!_alchemyAPI.GetPublicationDate(OnGetPublicationDateHtml, OnFail, _watson_beats_jeopardy_html))
        {
            Log.Debug("ExampleAlchemyLanguage.GetPublicationDate()", "Failed to get publication dates by html POST");
        }
        while (!_getPubDateHTMLTested)
        {
            yield return(null);
        }

        //Get Relations URL POST
        if (!_alchemyAPI.GetRelations(OnGetRelationsUrl, OnFail, _exampleURL_watsonJeopardy))
        {
            Log.Debug("ExampleAlchemyLanguage.GetRelations()", "Failed to get relations by text POST");
        }
        while (!_getRelationsURLTested)
        {
            yield return(null);
        }

        //Get Relations Text POST
        if (!_alchemyAPI.GetRelations(OnGetRelationsText, OnFail, _exampleText_watsonJeopardy))
        {
            Log.Debug("ExampleAlchemyLanguage.GetRelations()", "Failed to get relations by text POST");
        }
        while (!_getRelationsTextTested)
        {
            yield return(null);
        }

        //Get Relations HTML POST
        if (!_alchemyAPI.GetRelations(OnGetRelationsHtml, OnFail, _watson_beats_jeopardy_html))
        {
            Log.Debug("ExampleAlchemyLanguage.GetRelations()", "Failed to get relations by HTML POST");
        }
        while (!_getRelationsHTMLTested)
        {
            yield return(null);
        }

        //Get Sentiment URL POST
        if (!_alchemyAPI.GetTextSentiment(OnGetTextSentimentUrl, OnFail, _exampleURL_watsonJeopardy))
        {
            Log.Debug("ExampleAlchemyLanguage.GetTextSentiment()", "Failed to get sentiment by text POST");
        }
        while (!_getTextSentimentURLTested)
        {
            yield return(null);
        }

        //Get Sentiment Text POST
        if (!_alchemyAPI.GetTextSentiment(OnGetTextSentimentText, OnFail, _exampleText_watsonJeopardy))
        {
            Log.Debug("ExampleAlchemyLanguage.GetTextSentiment()", "Failed to get sentiment by text POST");
        }
        while (!_getTextSentimentTextTested)
        {
            yield return(null);
        }

        //Get Sentiment HTML POST
        if (!_alchemyAPI.GetTextSentiment(OnGetTextSentimentHtml, OnFail, _watson_beats_jeopardy_html))
        {
            Log.Debug("ExampleAlchemyLanguage.GetTextSentiment()", "Failed to get sentiment by HTML POST");
        }
        while (!_getTextSentimentHTMLTested)
        {
            yield return(null);
        }

        //Get Targeted Sentiment URL POST
        if (!_alchemyAPI.GetTargetedSentiment(OnGetTargetedSentimentUrl, OnFail, _exampleURL_watsonJeopardy, "Jeopardy|Jennings|Watson"))
        {
            Log.Debug("ExampleAlchemyLanguage.GetTargetedSentiment()", "Failed to get targeted sentiment by text POST");
        }
        while (!_getTargetedSentimentURLTested)
        {
            yield return(null);
        }

        //Get Targeted Sentiment Text POST
        if (!_alchemyAPI.GetTargetedSentiment(OnGetTargetedSentimentText, OnFail, _exampleText_watsonJeopardy, "Jeopardy|Jennings|Watson"))
        {
            Log.Debug("ExampleAlchemyLanguage.GetTargetedSentiment()", "Failed to get targeted sentiment by text POST");
        }
        while (!_getTargetedSentimentTextTested)
        {
            yield return(null);
        }

        //Get Targeted Sentiment HTML POST
        if (!_alchemyAPI.GetTargetedSentiment(OnGetTargetedSentimentHtml, OnFail, _watson_beats_jeopardy_html, "Jeopardy|Jennings|Watson"))
        {
            Log.Debug("ExampleAlchemyLanguage.GetTargetedSentiment()", "Failed to get targeted sentiment by HTML POST");
        }
        while (!_getTargetedSentimentHTMLTested)
        {
            yield return(null);
        }

        //Get Taxonomy URL POST
        if (!_alchemyAPI.GetRankedTaxonomy(OnGetRankedTaxonomyUrl, OnFail, _exampleURL_watsonJeopardy))
        {
            Log.Debug("ExampleAlchemyLanguage.GetRankedTaxonomy()", "Failed to get ranked taxonomy by text POST");
        }
        while (!_getRankedTaxonomyURLTested)
        {
            yield return(null);
        }

        //Get Taxonomy Text POST
        if (!_alchemyAPI.GetRankedTaxonomy(OnGetRankedTaxonomyText, OnFail, _exampleText_watsonJeopardy))
        {
            Log.Debug("ExampleAlchemyLanguage.GetRankedTaxonomy9", "Failed to get ranked taxonomy by text POST");
        }
        while (!_getRankedTaxonomyTextTested)
        {
            yield return(null);
        }

        //Get Taxonomy HTML POST
        if (!_alchemyAPI.GetRankedTaxonomy(OnGetRankedTaxonomyHtml, OnFail, _watson_beats_jeopardy_html))
        {
            Log.Debug("ExampleAlchemyLanguage.GetRankedTaxonomy()", "Failed to get ranked taxonomy by HTML POST");
        }
        while (!_getRankedTaxonomyHTMLTested)
        {
            yield return(null);
        }

        //Get Text HTML POST
        if (!_alchemyAPI.GetText(OnGetTextHtml, OnFail, _watson_beats_jeopardy_html))
        {
            Log.Debug("ExampleAlchemyLanguage.GetText()", "Failed to get text by text POST");
        }
        while (!_getTextHTMLTested)
        {
            yield return(null);
        }

        //Get Text URL POST
        if (!_alchemyAPI.GetText(OnGetTextUrl, OnFail, _exampleURL_watsonJeopardy))
        {
            Log.Debug("ExampleAlchemyLanguage.GetText()", "Failed to get text by text POST");
        }
        while (!_getTextURLTested)
        {
            yield return(null);
        }

        //Get Raw Text HTML POST
        if (!_alchemyAPI.GetRawText(OnGetRawTextHtml, OnFail, _watson_beats_jeopardy_html))
        {
            Log.Debug("ExampleAlchemyLanguage.GetRawText()", "Failed to get raw text by text POST");
        }
        while (!_getRawTextHTMLTested)
        {
            yield return(null);
        }

        //Get Raw Text URL POST
        if (!_alchemyAPI.GetRawText(OnGetRawTextUrl, OnFail, _exampleURL_watsonJeopardy))
        {
            Log.Debug("ExampleAlchemyLanguage.GetRawText()", "Failed to get raw text by text POST");
        }
        while (!_getRawTextURLTested)
        {
            yield return(null);
        }

        //Get Title HTML POST
        if (!_alchemyAPI.GetTitle(OnGetTitleHtml, OnFail, _watson_beats_jeopardy_html))
        {
            Log.Debug("ExampleAlchemyLanguage.GetTitle()", "Failed to get title by text POST");
        }
        while (!_getTitleHTMLTested)
        {
            yield return(null);
        }

        //Get Title URL POST
        if (!_alchemyAPI.GetTitle(OnGetTitleUrl, OnFail, _exampleURL_watsonJeopardy))
        {
            Log.Debug("ExampleAlchemyLanguage.GetTitle()", "Failed to get title by text POST");
        }
        while (!_getTitleURLTested)
        {
            yield return(null);
        }

        //  Get Combined Data URL POST
        if (!_alchemyAPI.GetCombinedData(OnGetCombinedDataUrl, OnFail, _exampleURL_watsonJeopardy, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true))
        {
            Log.Debug("ExampleAlchemyLanguage.GetCombinedData()", "Failed to get combined data by text POST");
        }
        while (!_getCombinedDataURLTested)
        {
            yield return(null);
        }

        //Get Combined Data Text POST
        if (!_alchemyAPI.GetCombinedData(OnGetCombinedDataText, OnFail, _exampleText_watsonJeopardy, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true))
        {
            Log.Debug("ExampleAlchemyLanguage.GetCombinedData()", "Failed to get combined data by text POST");
        }
        while (!_getCombinedDataTextTested)
        {
            yield return(null);
        }

        //Get Combined Data HTML POST
        if (!_alchemyAPI.GetCombinedData(OnGetCombinedDataHtml, OnFail, _watson_beats_jeopardy_html, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true))
        {
            Log.Debug("ExampleAlchemyLanguage.GetCombinedData()", "Failed to get combined data by HTML POST");
        }
        while (!_getCombinedDataHTMLTested)
        {
            yield return(null);
        }

        Log.Debug("ExampleAlchemyLanguage.Examples()", "Alchemy Language examples complete");
    }
Esempio n. 2
0
        public override IEnumerator RunTest()
        {
            LogSystem.InstallDefaultReactors();

            try
            {
                VcapCredentials vcapCredentials = new VcapCredentials();
                fsData          data            = null;

                //  Get credentials from a credential file defined in environmental variables in the VCAP_SERVICES format.
                //  See https://www.ibm.com/watson/developercloud/doc/common/getting-started-variables.html.
                var environmentalVariable = Environment.GetEnvironmentVariable("VCAP_SERVICES");

                var fileContent = File.ReadAllText(environmentalVariable);

                //  Add in a parent object because Unity does not like to deserialize root level collection types.
                fileContent = Utility.AddTopLevelObjectToJson(fileContent, "VCAP_SERVICES");

                //  Convert json to fsResult
                fsResult r = fsJsonParser.Parse(fileContent, out data);
                if (!r.Succeeded)
                {
                    throw new WatsonException(r.FormattedMessages);
                }

                //  Convert fsResult to VcapCredentials
                object obj = vcapCredentials;
                r = _serializer.TryDeserialize(data, obj.GetType(), ref obj);
                if (!r.Succeeded)
                {
                    throw new WatsonException(r.FormattedMessages);
                }

                //  Set credentials from imported credntials
                Credential credential = vcapCredentials.VCAP_SERVICES["alchemy_api"][TestCredentialIndex].Credentials;
                _apikey = credential.Apikey.ToString();
                _url    = credential.Url.ToString();
            }
            catch
            {
                Log.Debug("TestAlchemyLanguage", "Failed to get credentials from VCAP_SERVICES file. Please configure credentials to run this test. For more information, see: https://github.com/watson-developer-cloud/unity-sdk/#authentication");
            }

            //  Create credential and instantiate service
            Credentials credentials = new Credentials(_apikey, _url);

            _alchemyAPI = new AlchemyAPI(credentials);

            _watson_beats_jeopardy_html = Application.dataPath + "/Watson/Examples/ServiceExamples/TestData/watson_beats_jeopardy.html";

            //  Get Author URL POST
            if (!_alchemyAPI.GetAuthors(OnGetAuthorsUrl, _exampleURL_watsonJeopardy))
            {
                Log.Debug("ExampleAlchemyLanguage", "Failed to get authors URL POST!");
            }
            while (!_getAuthorsURLTested)
            {
                yield return(null);
            }

            //Get Author HTML POST
            if (!_alchemyAPI.GetAuthors(OnGetAuthorsHtml, _watson_beats_jeopardy_html))
            {
                Log.Debug("ExampleAlchemyLanguage", "Failed to get authors HTML POST!");
            }
            while (!_getAuthorsHTMLTested)
            {
                yield return(null);
            }

            ////Get Concepts Text POST
            if (!_alchemyAPI.GetRankedConcepts(OnGetConceptsText, _exampleText_watsonJeopardy))
            {
                Log.Debug("ExampleAlchemyLanguage", "Failed to get concepts Text POST!");
            }
            while (!_getRankedConceptsTextTested)
            {
                yield return(null);
            }

            //Get Concepts HTML POST
            if (!_alchemyAPI.GetRankedConcepts(OnGetConceptsHtml, _watson_beats_jeopardy_html))
            {
                Log.Debug("ExampleAlchemyLanguage", "Failed to get concepts HTML POST!");
            }
            while (!_getRankedConceptsHTMLTested)
            {
                yield return(null);
            }

            //Get Concepts URL POST
            if (!_alchemyAPI.GetRankedConcepts(OnGetConceptsUrl, _exampleURL_watsonJeopardy))
            {
                Log.Debug("ExampleAlchemyLanguage", "Failed to get concepts url POST!");
            }
            while (!_getRankedConceptsURLTested)
            {
                yield return(null);
            }

            //Get Date URL POST
            if (!_alchemyAPI.GetDates(OnGetDatesUrl, _exampleURL_watsonJeopardy))
            {
                Log.Debug("ExampleAlchemyLanguage", "Failed to get dates by URL POST");
            }
            while (!_getDatesURLTested)
            {
                yield return(null);
            }

            //Get Date Text POST
            if (!_alchemyAPI.GetDates(OnGetDatesText, _exampleText_watsonJeopardy))
            {
                Log.Debug("ExampleAlchemyLanguage", "Failed to get dates by text POST");
            }
            while (!_getDatesTextTested)
            {
                yield return(null);
            }

            //Get Date HTML POST
            if (!_alchemyAPI.GetDates(OnGetDatesHtml, _watson_beats_jeopardy_html))
            {
                Log.Debug("ExampleAlchemyLanguage", "Failed to get dates by HTML POST");
            }
            while (!_getDatesHTMLTested)
            {
                yield return(null);
            }

            //Get Emotions URL POST
            if (!_alchemyAPI.GetEmotions(OnGetEmotionsUrl, _exampleURL_watsonJeopardy, true))
            {
                Log.Debug("ExampleAlchemyLanguage", "Failed to get emotions by URL POST");
            }
            while (!_getEmotionURLTested)
            {
                yield return(null);
            }

            //Get Emotions Text POST
            if (!_alchemyAPI.GetEmotions(OnGetEmotionsText, _exampleText_watsonJeopardy, true))
            {
                Log.Debug("ExampleAlchemyLanguage", "Failed to get emotions by text POST");
            }
            while (!_getEmotionTextTested)
            {
                yield return(null);
            }

            //Get Emotions HTML POST
            if (!_alchemyAPI.GetEmotions(OnGetEmotionsHtml, _watson_beats_jeopardy_html, true))
            {
                Log.Debug("ExampleAlchemyLanguage", "Failed to get emotions by HTML POST");
            }
            while (!_getEmotionHTMLTested)
            {
                yield return(null);
            }

            //Extract Entities URL POST
            if (!_alchemyAPI.ExtractEntities(OnExtractEntitiesUrl, _exampleURL_watsonJeopardy))
            {
                Log.Debug("ExampleAlchemyLanguage", "Failed to get entities by URL POST");
            }
            while (!_getEntityExtractionURLTested)
            {
                yield return(null);
            }

            //Extract Entities Text POST
            if (!_alchemyAPI.ExtractEntities(OnExtractEntitiesText, _exampleText_watsonJeopardy))
            {
                Log.Debug("ExampleAlchemyLanguage", "Failed to get entities by text POST");
            }
            while (!_getEntityExtractionTextTested)
            {
                yield return(null);
            }

            //Extract Entities HTML POST
            if (!_alchemyAPI.ExtractEntities(OnExtractEntitiesHtml, _watson_beats_jeopardy_html))
            {
                Log.Debug("ExampleAlchemyLanguage", "Failed to get entities by HTML POST");
            }
            while (!_getEntityExtractionHTMLTested)
            {
                yield return(null);
            }

            //Detect Feeds URL POST
            if (!_alchemyAPI.DetectFeeds(OnDetectFeedsUrl, "http://time.com/newsfeed/"))
            {
                Log.Debug("ExampleAlchemyLanguage", "Failed to get feeds by URL POST");
            }
            while (!_detectFeedsURLTested)
            {
                yield return(null);
            }

            ////Detect Feeds HTML POST
            //if (!_alchemyAPI.DetectFeeds(OnDetectFeedsHtml, ycombinator_html))
            //    Log.Debug("ExampleAlchemyLanguage", "Failed to get feeds by HTML POST");
            //while (!_detectFeedsHTMLTested)
            //    yield return null;

            //Extract Keywords URL POST
            if (!_alchemyAPI.ExtractKeywords(OnExtractKeywordsUrl, _exampleURL_watsonJeopardy))
            {
                Log.Debug("ExampleAlchemyLanguage", "Failed to get keywords by URL POST");
            }
            while (!_getKeywordExtractionURLTested)
            {
                yield return(null);
            }

            //Extract Keywords Text POST
            if (!_alchemyAPI.ExtractKeywords(OnExtractKeywordsText, _exampleText_watsonJeopardy))
            {
                Log.Debug("ExampleAlchemyLanguage", "Failed to get keywords by text POST");
            }
            while (!_getKeywordExtractionTextTested)
            {
                yield return(null);
            }

            //Extract Keywords HTML POST
            if (!_alchemyAPI.ExtractKeywords(OnExtractKeywordsHtml, _watson_beats_jeopardy_html))
            {
                Log.Debug("ExampleAlchemyLanguage", "Failed to get keywords by HTML POST");
            }
            while (!_getKeywordExtractionHTMLTested)
            {
                yield return(null);
            }

            //Extract Languages URL POST
            if (!_alchemyAPI.GetLanguages(OnGetLanguagesUrl, _exampleURL_watsonJeopardy))
            {
                Log.Debug("ExampleAlchemyLanguage", "Failed to get languages by text POST");
            }
            while (!_getLanguageURLTested)
            {
                yield return(null);
            }

            //Extract Languages Text POST
            if (!_alchemyAPI.GetLanguages(OnGetLanguagesText, _exampleText_watsonJeopardy))
            {
                Log.Debug("ExampleAlchemyLanguage", "Failed to get languages by text POST");
            }
            while (!_getLanguageTextTested)
            {
                yield return(null);
            }

            //Extract Languages HTML POST
            if (!_alchemyAPI.GetLanguages(OnGetLanguagesHtml, _watson_beats_jeopardy_html))
            {
                Log.Debug("ExampleAlchemyLanguage", "Failed to get languages by HTML POST");
            }
            while (!_getLanguageHTMLTested)
            {
                yield return(null);
            }

            //Get Microformats URL POST
            if (!_alchemyAPI.GetMicroformats(OnGetMicroformatsUrl, _exampleURL_microformats))
            {
                Log.Debug("ExampleAlchemyLanguage", "Failed to get microformats by text POST");
            }
            while (!_getMicroformatURLTested)
            {
                yield return(null);
            }

            //Get Microformats HTML POST
            //if (!_alchemyAPI.GetMicroformats(OnGetMicroformatsHtml, microformats_html))
            //    Log.Debug("ExampleAlchemyLanguage", "Failed to get microformats by text POST");
            //while (!_getMicroformatHTMLTested)
            //    yield return null;

            //Get PublicationDate URL POST
            if (!_alchemyAPI.GetPublicationDate(OnGetPublicationDateUrl, _exampleURL_watsonJeopardy))
            {
                Log.Debug("ExampleAlchemyLanguage", "Failed to get publication dates by url POST");
            }
            while (!_getPubDateURLTested)
            {
                yield return(null);
            }

            //Get PublicationDate HTML POST
            if (!_alchemyAPI.GetPublicationDate(OnGetPublicationDateHtml, _watson_beats_jeopardy_html))
            {
                Log.Debug("ExampleAlchemyLanguage", "Failed to get publication dates by html POST");
            }
            while (!_getPubDateHTMLTested)
            {
                yield return(null);
            }

            //Get Relations URL POST
            if (!_alchemyAPI.GetRelations(OnGetRelationsUrl, _exampleURL_watsonJeopardy))
            {
                Log.Debug("ExampleAlchemyLanguage", "Failed to get relations by text POST");
            }
            while (!_getRelationsURLTested)
            {
                yield return(null);
            }

            //Get Relations Text POST
            if (!_alchemyAPI.GetRelations(OnGetRelationsText, _exampleText_watsonJeopardy))
            {
                Log.Debug("ExampleAlchemyLanguage", "Failed to get relations by text POST");
            }
            while (!_getRelationsTextTested)
            {
                yield return(null);
            }

            //Get Relations HTML POST
            if (!_alchemyAPI.GetRelations(OnGetRelationsHtml, _watson_beats_jeopardy_html))
            {
                Log.Debug("ExampleAlchemyLanguage", "Failed to get relations by HTML POST");
            }
            while (!_getRelationsHTMLTested)
            {
                yield return(null);
            }

            //Get Sentiment URL POST
            if (!_alchemyAPI.GetTextSentiment(OnGetTextSentimentUrl, _exampleURL_watsonJeopardy))
            {
                Log.Debug("ExampleAlchemyLanguage", "Failed to get sentiment by text POST");
            }
            while (!_getTextSentimentURLTested)
            {
                yield return(null);
            }

            //Get Sentiment Text POST
            if (!_alchemyAPI.GetTextSentiment(OnGetTextSentimentText, _exampleText_watsonJeopardy))
            {
                Log.Debug("ExampleAlchemyLanguage", "Failed to get sentiment by text POST");
            }
            while (!_getTextSentimentTextTested)
            {
                yield return(null);
            }

            //Get Sentiment HTML POST
            if (!_alchemyAPI.GetTextSentiment(OnGetTextSentimentHtml, _watson_beats_jeopardy_html))
            {
                Log.Debug("ExampleAlchemyLanguage", "Failed to get sentiment by HTML POST");
            }
            while (!_getTextSentimentHTMLTested)
            {
                yield return(null);
            }

            //Get Targeted Sentiment URL POST
            if (!_alchemyAPI.GetTargetedSentiment(OnGetTargetedSentimentUrl, _exampleURL_watsonJeopardy, "Jeopardy|Jennings|Watson"))
            {
                Log.Debug("ExampleAlchemyLanguage", "Failed to get targeted sentiment by text POST");
            }
            while (!_getTargetedSentimentURLTested)
            {
                yield return(null);
            }

            //Get Targeted Sentiment Text POST
            if (!_alchemyAPI.GetTargetedSentiment(OnGetTargetedSentimentText, _exampleText_watsonJeopardy, "Jeopardy|Jennings|Watson"))
            {
                Log.Debug("ExampleAlchemyLanguage", "Failed to get targeted sentiment by text POST");
            }
            while (!_getTargetedSentimentTextTested)
            {
                yield return(null);
            }

            //Get Targeted Sentiment HTML POST
            if (!_alchemyAPI.GetTargetedSentiment(OnGetTargetedSentimentHtml, _watson_beats_jeopardy_html, "Jeopardy|Jennings|Watson"))
            {
                Log.Debug("ExampleAlchemyLanguage", "Failed to get targeted sentiment by HTML POST");
            }
            while (!_getTargetedSentimentHTMLTested)
            {
                yield return(null);
            }

            //Get Taxonomy URL POST
            if (!_alchemyAPI.GetRankedTaxonomy(OnGetRankedTaxonomyUrl, _exampleURL_watsonJeopardy))
            {
                Log.Debug("ExampleAlchemyLanguage", "Failed to get ranked taxonomy by text POST");
            }
            while (!_getRankedTaxonomyURLTested)
            {
                yield return(null);
            }

            //Get Taxonomy Text POST
            if (!_alchemyAPI.GetRankedTaxonomy(OnGetRankedTaxonomyText, _exampleText_watsonJeopardy))
            {
                Log.Debug("ExampleAlchemyLanguage", "Failed to get ranked taxonomy by text POST");
            }
            while (!_getRankedTaxonomyTextTested)
            {
                yield return(null);
            }

            //Get Taxonomy HTML POST
            if (!_alchemyAPI.GetRankedTaxonomy(OnGetRankedTaxonomyHtml, _watson_beats_jeopardy_html))
            {
                Log.Debug("ExampleAlchemyLanguage", "Failed to get ranked taxonomy by HTML POST");
            }
            while (!_getRankedTaxonomyHTMLTested)
            {
                yield return(null);
            }

            //Get Text HTML POST
            if (!_alchemyAPI.GetText(OnGetTextHtml, _watson_beats_jeopardy_html))
            {
                Log.Debug("ExampleAlchemyLanguage", "Failed to get text by text POST");
            }
            while (!_getTextHTMLTested)
            {
                yield return(null);
            }

            //Get Text URL POST
            if (!_alchemyAPI.GetText(OnGetTextUrl, _exampleURL_watsonJeopardy))
            {
                Log.Debug("ExampleAlchemyLanguage", "Failed to get text by text POST");
            }
            while (!_getTextURLTested)
            {
                yield return(null);
            }

            //Get Raw Text HTML POST
            if (!_alchemyAPI.GetRawText(OnGetRawTextHtml, _watson_beats_jeopardy_html))
            {
                Log.Debug("ExampleAlchemyLanguage", "Failed to get raw text by text POST");
            }
            while (!_getRawTextHTMLTested)
            {
                yield return(null);
            }

            //Get Raw Text URL POST
            if (!_alchemyAPI.GetRawText(OnGetRawTextUrl, _exampleURL_watsonJeopardy))
            {
                Log.Debug("ExampleAlchemyLanguage", "Failed to get raw text by text POST");
            }
            while (!_getRawTextURLTested)
            {
                yield return(null);
            }

            //Get Title HTML POST
            if (!_alchemyAPI.GetTitle(OnGetTitleHtml, _watson_beats_jeopardy_html))
            {
                Log.Debug("ExampleAlchemyLanguage", "Failed to get title by text POST");
            }
            while (!_getTitleHTMLTested)
            {
                yield return(null);
            }

            //Get Title URL POST
            if (!_alchemyAPI.GetTitle(OnGetTitleUrl, _exampleURL_watsonJeopardy))
            {
                Log.Debug("ExampleAlchemyLanguage", "Failed to get title by text POST");
            }
            while (!_getTitleURLTested)
            {
                yield return(null);
            }

            //  Get Combined Data URL POST
            if (!_alchemyAPI.GetCombinedData(OnGetCombinedDataUrl, _exampleURL_watsonJeopardy, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true))
            {
                Log.Debug("ExampleAlchemyLanguage", "Failed to get combined data by text POST");
            }
            while (!_getCombinedDataURLTested)
            {
                yield return(null);
            }

            //Get Combined Data Text POST
            if (!_alchemyAPI.GetCombinedData(OnGetCombinedDataText, _exampleText_watsonJeopardy, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true))
            {
                Log.Debug("ExampleAlchemyLanguage", "Failed to get combined data by text POST");
            }
            while (!_getCombinedDataTextTested)
            {
                yield return(null);
            }

            //Get Combined Data HTML POST
            if (!_alchemyAPI.GetCombinedData(OnGetCombinedDataHtml, _watson_beats_jeopardy_html, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true))
            {
                Log.Debug("ExampleAlchemyLanguage", "Failed to get combined data by HTML POST");
            }
            while (!_getCombinedDataHTMLTested)
            {
                yield return(null);
            }

            Log.Debug("ExampleAlchemyLanguage", "Alchemy Language examples complete");

            Dictionary <string, string> queryFields = new Dictionary <string, string>();

            queryFields.Add(Fields.EnrichedUrlRelationsRelationSubjectText, "Obama");
            queryFields.Add(Fields.EnrichedUrlCleanedtitle, "Washington");
            string[] returnFields = { Fields.EnrichedUrlEntities, Fields.EnrichedUrlKeywords };

            if (!_alchemyAPI.GetNews(OnGetNews, returnFields, queryFields))
            {
                Log.Debug("ExampleAlchemyDataNews", "Failed to get news!");
            }

            while (!_getNewsTested)
            {
                yield return(null);
            }

            Log.Debug("ExampleAlchemyDataNews", "Alchemy data news examples complete!");

            yield break;
        }