Is Mysql ACID Compliant? Is Mysql not an ACID compliant according to Postgresql? In some blogs I see Mysql is not ACID compliant. How true is that?

Let't not consider the replication here, lets consider a standalone and how efficient is Mysql ACID?

In my understanding for Mysql-ACID.


  A - Atomicity (Set of transactions should all be committed if one
  fails it has to rollback. Yes means all are committed , no means even
  one failed it has to Rollback).
  
  I.E. Features that supports in Mysql are.
  
  
  start Transaction; ..... commit ; 
  auto_commit=1;
  
  
  C - Consistency.
  
  ( PK,FK,UK,NOT-NULL). It adheres to Relations and constraints for
  Databases. Instance a parent key can be deleted only when its child
  key is removed.
  
  I - Isolation.  Isolation between users and their state of commit.
  
  Read Repeatable Read Uncommitted Read Committed Serialized 
  
  D - Durability. At the event of DB crash innodb recovers the DB by
  applying committed transaction from iblog file and discards
  not-committed transaction.


Click here for the source of this question.   - Is it because the blog is created @2001? 

UPDATE Jun-30-2017: As per "Evan Carroll" response and I have personally tested the blog experiment on 5.7.18-enterprise. The results obtained from the experiment seems to be Mysql is Not an ACID Compliant.
If you use InnoDB or a similar storage engine then it should be ACID compliant (ref: https://en.wikipedia.org/wiki/InnoDB). myISAM, the old default and still very commonly used, most definitely isn't ACID compliant. If you mix the two (you might find simpler table types perform better and are acceptable for volatile data that can and will be reproduced again, such as staging tables for ETL processes) then you solution will not be entirely compliant.

A large caveat with ACID compliance is that for performance reasons most databases use an isolation level that does not guarantee the "I" part - this is within the ANSI SQL specs. To offer proper Isolation you need to guarantee that transactions are serialisable, an isolation level that some DBs don't even support. For example MySQL+InnoDB defaults to "repeatable read", while MS SQL Server defaults to the slightly more strict "read committed", both offer "serialisable" but it is not the default. Why isn't is always supported and usually not the default? Performance: a full isolation requirement can significantly limit concurrency.

There are a few good articles on the subject. For one example http://www.bailis.org/blog/when-is-acid-acid-rarely/ is a short and informative place to start with some interesting discussion in the comments.