Healthy toxic processing is apparent in the shine of the horse’s coat, clear, bright eyes and alert, energetic behavior.  Proper detox can also improve overall performance.

Healthy Detoxification makes for Healthy Horses

Major contributing factors to toxicity are preservatives, pesticide and herbicide residues, insecticides, toxic metals, cleaning solutions and fertilizer run-off from farm fields. Many toxic metals are commonly present in air and water. Multiple stresses, along with high-sugar, high-starch, highly processed feeds can also contribute to sluggish elimination and detoxification processes.

Specific, key ingredients can support healthy toxic processing and elimination to provide support for the detoxification systems.

DL-Methionine, the sulphur containing amino acid, is an effective detoxifier of arsenic.

MSM supports healthy detoxification processes, kidney and liver function and oxidative reactions.  It is also effective at improving arsenic elimination.

Beta Alanine supports healthy muscular function, detoxification and metabolism.

Magnesium supports cellular energy production, healthy glucose metabolism and acts as a buffer for the acids from toxic exposure and elimination.

Trimethylglycine (TMG) and Dimethylglycine (DMG) work synergistically to support the basic detoxification mechanisms by contributing the amino acid glycine, as well as supplying valuable methyl groups, which are essential for the inactivation and elimination of toxic substances.

Acetyl L-Carnitine is essential in the healthy processing of fatty acids as a source of energy, contributes to healthy endocrine balance and aids in the detoxification of the most common environmental pollutants.

Niacin (B3), Calcium Pantothenate (B5), Thiamine (B1), Pyridoxine (B6), Riboflavin (B2) and Vitamin B12 support healthy liver function, energy production, metabolic balance, stress recovery and detoxification.

Mixed Tocopherols including Vitamin E support healthy cellular function, help reduce excessive oxidative stress and protect against free radical damage.

Zinc and Copper have synergistic roles in helping combat environmental toxic effects, reducing excessive oxidation and supporting tissue integrity.

Chromium supports normal, healthy glucose metabolism and energy production.

Selenium directly supports healthy detoxification mechanisms, supports liver function, helps fight the effect of environmental toxins and exhibits a cellular protective benefit.

• Higher toenail selenium levels were associated with a reduced risk for advanced prostate cancer.
• Toenail selenium levels reflect long-term selenium intake.
• Further studies in low-selenium populations are required.

WASHINGTON, D.C. — A greater level of toenail selenium was associated with a significant decrease in the risk for advanced prostate cancer, according to data presented at the AACR Annual Meeting 2013, held in Washington, D.C., April 6-10.

“This could mean, based on our data and based on data from other studies, that selenium is a modifiable risk factor of advanced, clinically relevant prostate cancer,” said Milan S. Geybels, M.Sc., a doctoral candidate in cancer epidemiology at Maastricht University, in Maastricht, the Netherlands.

The Netherlands Cohort Study on diet and cancer is a prospective cohort study that includes 58,279 men who were aged 55 to 69 years at entry in September 1986. Geybels and colleagues analyzed data from 898 men who were diagnosed with advanced prostate cancer during 17.3 years of follow-up of the cohort.

According to Geybels, previous studies investigating the association between selenium levels and prostate cancer have yielded varying results. One large clinical trial showed that selenium supplementation had no protective effect, while several prospective, observational studies indicated that higher levels of selenium were associated with a reduced prostate cancer risk, especially for advanced prostate cancer.

“Our study is interesting because we specifically investigated men with advanced prostate cancer, a type of prostate cancer associated with a poorer prognosis,” Geybels said. “Also, while most of the prior research, including the large clinical trial, involved men with moderate-to-high selenium levels, men in The Netherlands Cohort Study have selenium levels that range from low to moderate. This is important because low selenium is expected to be related to a higher disease risk.”

He and his colleagues chose toenail selenium as the study biomarker because it reflects long-term exposure, as opposed to blood, which is best for monitoring recent selenium exposures.

The data revealed that greater levels of toenail selenium were associated with a substantially reduced risk for advanced prostate cancer. Men with the highest toenail selenium levels had a more than 60 percent lower risk for advanced prostate cancer compared with men with the lowest toenail selenium levels.

“Our findings need to be replicated in further prospective studies, with an extended follow-up for the assessment of incident advanced prostate cancer, and with a wide range of toenail selenium that includes low selenium levels,” Geybels said. “If our results can be confirmed, a prevention trial of selenium and prostate cancer in a low-selenium population may be justified.”

Press registration for the AACR Annual Meeting 2013 is free to qualified journalists and public information officers.

Follow the AACR on Twitter: @aacr #aacr
Follow the AACR on Facebook: http://www.facebook.com/aacr.org

About the American Association for Cancer Research
Founded in 1907, the American Association for Cancer Research (AACR) is the world’s first and largest professional organization dedicated to advancing cancer research and its mission to prevent and cure cancer. AACR membership includes more than 34,000 laboratory, translational and clinical researchers; population scientists; other health care professionals; and cancer advocates residing in more than 90 countries. The AACR marshals the full spectrum of expertise of the cancer community to accelerate progress in the prevention, biology, diagnosis and treatment of cancer by annually convening more than 20 conferences and educational workshops, the largest of which is the AACR Annual Meeting with more than 17,000 attendees. In addition, the AACR publishes eight peer-reviewed scientific journals and a magazine for cancer survivors, patients and their caregivers. The AACR funds meritorious research directly as well as in cooperation with numerous cancer organizations. As the scientific partner of Stand Up To Cancer, the AACR provides expert peer review, grants administration and scientific oversight of team science and individual grants in cancer research that have the potential for near-term patient benefit. The AACR actively communicates with legislators and policymakers about the value of cancer research and related biomedical science in saving lives from cancer. For more information about the AACR, visit www.AACR.org.

Media Contact:
Jeremy Moore
(215) 446-7109
Jeremy.Moore@aacr.org
In Washington, D.C.,
April 6-10, 2013:
(202) 249-4005

Vitamin C helps reduce inflammation, provides anti-oxidant support, helps with bacterial infections, helps protect from damage caused by loss of blood supply, and helps reduce coagulation of the blood within the kidney.

Co-Enzyme Q10 is a natural antioxidant and has the ability to enhance energy and immune system function. It is essential for the function of the mitochondria, which converts energy into usable forms and is involved in cell division and growth.

Selenium has the support of some of the largest browser vendors who have taken (or are taking) steps to make Selenium a native part of their browser. It is also the core technology in countless other browser automation tools, APIs and frameworks.

There are no selenium specific commands to do the database testing. But, you have the work around with native language. Here is the example how you can make database testing in selenium. The below mentioned commands will help you to begin with.

Before you use the below code You should have created the DSN name for MS SQL Server DB or Oracle DB using ODBC drivers. Here the name that we have used for the database DSN name is QT_Flight32. And the table in that database we are using is Orders. Hope the remaining steps you can easily understand.

//KEEP THE NAME OF THE PACKAGE
package com.src.test;

//IMPORT THE SQL PACKAGE
import java.sql.* ;

//DECLARE THE CLASS
class JDBCODBCTestCase
{

//WRITE THE MAIN METHOD TO CONNECT TO THE DATABASE
public static void main( String args[] )
{

try{

// LOAD THE DATABASE DRIVER
Class.forName( “sun.jdbc.odbc.JdbcOdbcDriver” ) ;

// ESTABLISH THE CONNECTION TO THE DATABASE
Connection conn = DriverManager.getConnection( “jdbc:odbc:QT_Flight32″ ) ;

// GET A STATEMENT FOR THE CONNECTION
Statement stmt = conn.createStatement() ;

// PREPARE THE SQL STATEMENT
String strSQL = “SELECT * FROM Orders”;

// EXECUTE THE SQL QUERY AND STORE IN RESULTS SET
ResultSet rs = stmt.executeQuery( strSQL ) ;

// LOOP THE RESULT TILL IT REACHED END
// rs.getString(1) – FIRST COLUMN
// rs.getString(2) – SECOND COLUMN ETC
while( rs.next() )
System.out.println( rs.getString(1) + rs.getString(2)+ rs.getString(3)+ rs.getString(4)) ;

// CLOSE THE RESULT, STATEMENT AND CONNECTION
rs.close() ;
stmt.close() ;
conn.close() ;

}
// HANDLE THE SQL EXCEPTION
catch( SQLException se ) {

System.out.println( “SQL Exception:” ) ;

// PRINT TILL ALL THE ECEPTIONS ARE RAISED
while( se != null ) {

System.out.println( “State : ” + se.getSQLState() ) ;
System.out.println( “Message: ” + se.getMessage() ) ;
System.out.println( “Error : ” + se.getErrorCode() ) ;

se = se.getNextException() ;

}

}
//CATCH THE CLASS EXCEPTION
catch( Exception e ) {

System.out.println( e ) ;

}
}

}

Export the test to C# web drive

This is how it looks like after export

Open visual studio, create new test project

By default the file UnitTest1.cs is created

Create a new cs file, name it for example GoogleSearch

Copy the code from the cs file generated by selenium and paste it in the file GoogleSearch.cs

Add reference in the project to Selenium .Net WebDriver, WebDriver.dll and WebDriver.Support.dl

Now the references added, you can see that the editor recognizes the selenium name spaces

using OpenQA.Selenium;
using OpenQA.Selenium.Firefox;
using OpenQA.Selenium.Support.UI;

Find and replace “TestFixture” to “TestClass”, “SetUp” to “TestInitialize()”, “Test” to “TestMethod”, “TearDown” to “TestCleanup()”

To run with Chrome, download chromedriver.exe from https://code.google.com/p/chromedriver/downloads/list, place it in the bin folder

Change the driver in the code to Chrome then run the test

driver = new OpenQA.Selenium.Chrome.ChromeDriver();

Running the test, chrome will open, and Google search page will be displayed, displaying search results then closed

This was a step by step example on running selenium test from visual studio

Brooding.

I was on the lookout for a good unit testing suite for Javascript. I had previously been introduced to the YUI Testing Framework, which provides a console and enables you to easily write and run tests from a browser window, but one limitation of YUI is that, out of the box, it doesn’t support interaction with the site itself. So, while the basic usage is good for verifying libraries and similar, I wanted something that was able to interact with page elements in a different way.

Enter Selenium. Now, here’s a way to not only automate web interactions, but to make them into automated unit tests for my research projects. This post is going to serve as a brief introduction to Selenium and how to start using it to interact with websites.

Selenium

Selenium is a web automation framework that enables a user to essentially script a web site. In this post we’ll talk about using Selenium version 2, which is the main, up-to-date version of the software.

There are two main ways for you to interact with a website.

The Selenium IDE: Recording actions by Demonstration

First, you can use the Selenium IDE, which is a Firefox plugin that allows you to demonstrate interactions with a web site. You essentially record actions and then as you click around the page, type in form elements, and push buttons, the IDE records the actions for you in a pseudo-markup language. (If you happen to follow my other research, it is actually somewhat similar to CoScripter, another program-by-demonstration tool for the web, but with better web interaction and fewer features. For example, Selenium cannot store temporary data into tables.)

Thus, even with minimal web development or programming experience, you could create a script for Selenium that plays back, for example, a series of clicks on a page, completes a survey, or similar.

There are some limitations with the IDE. The main one that led me to using the WebDriver (below) is that it doesn’t interact very well with “contentEditable” div tags and other HTML5 elements.

Note that the Selenium IDE is version 1.x, which does NOT correspond to Selenium itself (which is version 2.x).

The Selenium WebDriver: Programming actions in code

The second way to interact with a website is using the Selenium Webdriver, which is a driver that essentially launches a website and then enables you to look through that website’s DOM to interact with elements on the page. Thus, you can use your own browser, like Firefox or Internet Explorer to load and navigate a web site.

I wanted Selenium to be able to work with a highly interactive web app: Gidget. Gidget is a programming game for kids and teenagers that I am working on in collaboration with Andy Ko and Michael Lee. Gidget runs with a lot of HTML5, JQuery, and Javascript and is extremely visual – something that seems perfect for Selenium.

Unfortunately, since Gidget isn’t available publicly yet, I can’t actually put tests on the blog that’ll directly run Gidget so instead I’ll use Google.

Building a Selenium Script

Selenium has a number of bindings in Java, Ruby, Python, and Javascript. I personally chose to use Python – I like its concise syntax and the fact that it has pretty good library support. I’ll focus exclusively on Python in this particular post. Most of the Java bindings can be derived from the Python commands if you remove the underscores and instead use CamelCase – for example, “element.is_enabled()” in Python would be “element.isEnabled()” in Java.

To install Selenium, you generally need to only type

pip install selenium

assuming that Python exists already on your system.

The first place I’m going to point you at is the Selenium Documentation Example of WebDriver, where they already include an example of making a query on Google. Here’s a reproduction of the code.

from selenium import webdriver
from selenium.common.exceptions import TimeoutException
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC

# Create a new instance of the Firefox driver
driver = webdriver.Firefox()

# go to the google home page
driver.get("http://www.google.com")

# find the element that's name attribute is q (the google search box)
inputElement = driver.find_element_by_name("q")

# type in the search
inputElement.send_keys("Cheese!")

# submit the form (although google automatically searches now without submitting)
inputElement.submit()

# the page is ajaxy so the title is originally this:
print driver.title

try:
    # we have to wait for the page to refresh, the last thing that seems to be updated is the title
    WebDriverWait(driver, 10).until(EC.title_contains("cheese!"))

    # You should see "cheese! - Google Search"
    print driver.title

finally:
    driver.quit()

It works exactly as advertised and opens up a web browser, goes to Google, and then searches for “cheese!”. However, there are a number of features that are essential to actually testing web pages.

Waiting for Pages

The unfortunate reality of web pages nowadays is that you have to wait a lot. Whether it’s a form submit where you have to wait for the POST request to complete, or some really slow JQuery fading box, not everything you want to interact with is available. To get around this, you have to use the “wait” commands in Selenium.

The Selenium documents do provide a few examples but I had to do a lot of searching and testing to get things working so I’ll just provide my use cases here directly.

To wait for an element to appear in Selenium, you need to provide an explicit wait along with a condition. It basically waits until either the identified element loads, or until the timeout passes (at which point it will throw an exception). There is an example of that in the Selenium example above, but if you have Google Instant turned on, you’ll realise notice that Google now returns search results to you as soon as you start typing. How can you interact with page elements if you don’t even know what’s going to pop up, when?

In this case, we’re going to wait until the “Search Results” text pops up.

from selenium import webdriver
from selenium.common.exceptions import TimeoutException
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support.ui import Select
from selenium.webdriver.common.by import By
from selenium.webdriver.support import expected_conditions as EC
from selenium.common.exceptions import NoSuchElementException

if __name__ == "__main__":
    driver = webdriver.Firefox()
    wait = WebDriverWait(driver, 100)
    driver.get("http://google.com")
    
    inputElement = driver.find_element_by_name("q")
    inputElement.send_keys("Irwin Kwan")
    
    wait.until(EC.element_to_be_clickable((By.XPATH, "//a[@href='http://irwinhkwan.wordpress.com/']")))
    blog = driver.find_element_by_xpath("//a[@href='http://irwinhkwan.wordpress.com/']")
    blog.click()
    
    driver.quit()

Basically, the driver loads, we set up a “wait” that waits up to 100ms, and then we do a search on Google for my name. Note that we don’t actually submit the form – instead, we wait for the link to my blog to appear in the Google search results, find the element, then click on it. And yes, this is a cheap way to rack up those hits for my blog, so everyone run this code.

There are a lot of expected conditions available in Selenium and this is probably the most important thing to be aware of when first starting. You can’t interact with page elements unless they’re available, after all. Here are some of the useful ones:

• EC.element_to_be_clickable: Wait for the element to be clickable. Good for elements that aren’t always visible or enabled. I use this a lot in the game.
• EC.visibility_of_element_located: Wait for the element to be visible. A lot of pages load all of their content, but hide it from the user. Here’s how you ensure that what’s being interacted with is actually visible.
• EC.presence_of_element_located: The element exists somewhere on the page.

There are a lot of these expected conditions. A full list is available on the selenium.webdriver.support.expected_conditions API document page.

The second key aspect here is the interaction. To do this, you have to “find” the element. So far, I’ve used two main ways of finding an element: ID, and XPath.

Finding elements by ID

Finding an element by ID is pretty much what it sounds like: searching for an element using its ID tag. ID tags are unique in the DOM and are therefore ideal for searching and testing. You can use it like this:

driver.find_element_by_id("menubutton_id")

Finding elements by XPath

XPath is a query language designed to navigate XML. I won’t go through all of the details of XPath here, but I’ll present a few basic use cases. You basically can search on a number of conditions that you specify in the language so you can see if that element exists in the DOM.

• If you want to search if a specific tag exists:

  driver.find_element_by_xpath("//h1")

• If you want to search for nested tags:

  driver.find_element_by_xpath("/html/body/h1")

• If you want to search that text within the tags matches:

  driver.find_element_by_xpath("//h1[text()='Heading 1']")

• If you want to search for text in attributes

  driver.find_element_by_xpath("//img[@title='Irwin Kwan']")

With these two find_element commands, you can find most of what you need in your web pages. Selenium supports a number of other ways to search, including searching by CSS, but I haven’t needed to use it yet.

Dynamic Interactions with a Page

Another issue I encountered with the Gidget game is clicking through introduction text when I didn’t know how many pages were present. Essentially, the problem is that there’s a button that I have to push on the page, and if I push it a certain number of times, it’ll be disabled. However, I don’t know how many times I have to push it because it might be different each time.

I managed to get around this with a little fragment of code below:

wait.until(EC.element_to_be_clickable((By.ID, 'main_buttonMissionTextNext')))
while EC.element_to_be_clickable((By.ID,'main_buttonMissionTextNext')):
    driver.find_element_by_id("main_buttonMissionTextNext").click()
    if not driver.find_element_by_id("main_buttonMissionTextNext").click().is_enabled():
        break
    wait.until(EC.element_to_be_clickable((By.ID, 'main_buttonMissionTextNext')))

There were two gotchas here: First, I wasn’t aware of it at the time, but the button was actually regenerated whenever you clicked it, so I had to search for it again when I clicked it. Second, I didn’t realise that there was an is_enabled() function you could use to test if an element is enabled or not. But now, you know!

I posted a StackOverflow question about this (which I ended up answering myself).

Using the Selenium IDE and the Selenium WebDriver Together To Save Time

While writing code is nice and fun, HTML pages are very large and are covered with tags with various IDs. It becomes tedious very quickly, even with good web development debugging tools, to search through the DOM elements to identify what you need to interact with, then writing the code to search and click on it.

So work smarter, not harder and use the Selenium IDE. If you record your actions with a page and save it in the Selenium IDE, you can use “Export Test Case As… > Python 2 / unittest / WebDriver”. Now you have Python code for that series of actions that you just performed and can integrate it into your other tests.

In my case, I used the Selenium IDE to automatically complete an exit survey in Gidget, then exported it and used the code in my other test suites. It’s a great way to save time writing code.

Making your code into a Test Suite

In Python, the unit testing is built in. You simply have to import unittest, create a class that extends it, and then write your setup and teardown functions, along with a method beginning with “test”. Here’s the previous code for interacting with Google converted into a Python test suite.

import unittest

from selenium import webdriver
from selenium.common.exceptions import TimeoutException
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support.ui import Select
from selenium.webdriver.common.by import By
from selenium.webdriver.support import expected_conditions as EC
from selenium.common.exceptions import NoSuchElementException

class WebTester(unittest.TestCase):
    def setUp(self):
        self.driver = webdriver.Firefox()
        self.wait = WebDriverWait(self.driver, 100)
        
    def test_load_blog(self):
        self.driver.get("http://google.com")
    
        inputElement = self.driver.find_element_by_name("q")
        inputElement.send_keys("Irwin Kwan")
    
        self.wait.until(EC.element_to_be_clickable((By.XPATH, "//a[@href='http://irwinhkwan.wordpress.com/']")))
        blog = self.driver.find_element_by_xpath("//a[@href='http://irwinhkwan.wordpress.com/']")
        blog.click()
        
        self.wait.until(EC.visibility_of_element_located((By.XPATH, "//h2[text()='Irwin Kwan']")))
        self.assertTrue(self.driver.find_element_by_xpath("//h2[text()='Irwin Kwan']"))
    
    def tearDown(self):
        self.driver.quit()
    
if __name__ == "__main__":
    unittest.main()

If you place multiple test suite classes in the file, unittest will run them all. Selenium will launch a new, fresh browser instance for each one as well.

Conclusion: Web Automation is Pretty Cool

I’m really just a new user. Selenium has a number of features that I haven’t needed and therefore don’t know much about. There’s a “remote control” mode that allows you to use a separate server to run tests for you. There are ways to store session variables, load specific Firefox profiles with add-ons, and there is a “Selenium server” mode as well. If you need these features, chances are you’ll be able to find information about them on the Selenium site documents.

I feel that this information should set most people up with enough information to get started with Selenium and making it work for them in a useful way. I hope that this post is useful to you guys!

Happy automating!

BO-SE is similar, it is recommended 1 cc per 40# in lambs and that is the minimum weight it is to be given, read the label folks. It also has a whopping 68 units of E per cc. Its not recommended for pregnant ewes due to what is probably an occasional anaphylactic reaction.

Whats the most economical and safest answer? Feeding iodine, selenium and Vitamin E thru the salt. Big Gain Feeds have this product complete or if not in the area serviced by them we have products #6249 and #8770 that can be easily mixed with salt, #6249 contains E, #8770 doesn’t.
You certainly don’t need Vitamin E when animals are on pasture or early in fall when feed stuffs still retain their Vitamin E. These products provide iodine as well and complete you entire mineral needs for breeding sheep.

Whats the take home? Selenium and Vitamin E should be provided in the ration as a safer and more cost effective route of administration.

DON’T OVERDOSE OR REPEAT INJECTIONS OF THESE TWO PRODUCTS OR ACUTE DEATH MAY RESULT.

In automation while filling most of the forms we need to fill/select the drop down values also. For achieving this WebDriver has separate class called Select.

In this post we will see what are all different method available in Select class.

Get Selected Option(s)
If you want to verify whether the proper value got selected in particular drop down list you can make use of below methods.

1. getFirstSelectedOption();
2. getAllSelectedOptions() ;

getAllSelectedOptions() ;

• It will return List of All selected options belonging to this select tag. (This will be useful for multiselect picklist)

Handling multi-select pick list

Handling multi select pick list same as normal drop down( single pick list).
For selecting both Hyderabad, Bangalore option you need to use one of the below logics.

I hope you understand WebDriver Select class usage in automation.

Happy Selecting

Regards,
SantoshSarma

driver.getPageSource().contains(pattern)

or find the element with the text and assert that it is visible.

WebElement el = driver.findElement(By.xpath("//*[contains(.,'" + pattern + "')]"));

I find that the latter works better in most cases. I wrap it in a try/catch block to grab any NoSuchElementException.

$j("[id$='logActivitiesCheckbox']");

To get a WebElement object back from WebDriver I use this method:

  public WebElement getWebElementFromJquery(String jQuery) {
    WebElement jqElement = null;
    JavascriptExecutor js = (JavascriptExecutor) driver;
    String query = "return " + jQuery+ ".get(0);";
    try {
      jqElement = (WebElement) js.executeScript(query);
    } catch (Exception e) {
      logger.error("jQuery() " + e.getMessage());
    }
    return jqElement;
  }

 
  public List findElements(String identifier) {
    List el = null;
    try {
      if (identifier.indexOf("//") > -1) {
        el = driver.findElements(By.xpath(identifier));
      } else if (identifier.indexOf("link=") > -1) {
        String linkText = identifier.split("=")[1];
        el = (List) driver.findElements(By.linkText(linkText));
      } else {
        el = driver.findElements(By.id(identifier));
      }
    } catch (Exception e) {
      logger.error("findElements() " + e.getMessage());
    }
    return el;
  }

//td[contains(text(), 'Settings')]

Another example:

//div[contains(.,'Some Text')]

Sometimes there are cross-browser problems with using XPath. One solution is to get all elements with a specific tag name, and iterate through the list to match the values of specific attributes.

Selenium is a trace mineral found in the soil, water and, in small amounts, in some foods. Selenium is an antioxidant and, as a result, can help protect our bodies from free radical damage. It appears to have protective benefits against the development of prostate cancer. Low selenium levels may be linked to osteoarthritis and symptoms of pain, stiffness and loss of mobility, possibility by decreasing inflammation. HIV and Crohn’s disease have been linked to low selenium levels in the body. I recommend taking 55 mcg to 200 mcg daily as a supplement.  Dosages above 400 mcg are considered unsafe. Food sources of selenium include brazil nuts, walnuts, tuna, cod, red snapper, herring, grains, beef and poultry.

For more information about Selenium or other minerals see Healthy Diet and Nutrition for Women available on Amazon, Amazon Kindle and Womens Wellness Publishing.